86 files changed, 3256 insertions, 2318 deletions
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 5050c558c..fb7afe9fd 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -11,6 +11,7 @@ env:
  CARGO_INCREMENTAL: 0
  CARGO_NET_RETRY: 10
  RUN_SLOW_TESTS: 1
+  RUST_BACKTRACE: short
  RUSTFLAGS: -D warnings
  RUSTUP_MAX_RETRIES: 10
diff --git a/Cargo.lock b/Cargo.lock
index 8d81c4839..c07a9614a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11,9 +11,9 @@ dependencies = [
 [[package]]
 name = "anyhow"
-version = "1.0.27"
+version = "1.0.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "013a6e0a2cbe3d20f9c60b65458f7a7f7a5e636c5d0f45a5a6aee5d4b1f01785"
+checksum = "d9a60d744a80c30fcb657dfe2c1b22bcb3e814c1a1e3674f32bf5820b570fbff"
 [[package]]
 name = "anymap"
@@ -331,9 +331,9 @@ dependencies = [
 [[package]]
 name = "filetime"
-version = "0.2.8"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ff6d4dab0aa0c8e6346d46052e93b13a16cf847b54ed357087c35011048cc7d"
+checksum = "f59efc38004c988e4201d11d263b8171f49a2e7ec0bdbb71773433f271504a5e"
 dependencies = [
 "cfg-if",
 "libc",
@@ -435,9 +435,9 @@ dependencies = [
 [[package]]
 name = "hermit-abi"
-version = "0.1.8"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1010591b26bbfe835e9faeabeb11866061cc7dcebffd56ad7d0942d0e61aefd8"
+checksum = "725cf19794cf90aa94e65050cb4191ff5d8fa87a498383774c47b332e3af952e"
 dependencies = [
 "libc",
 ]
@@ -563,9 +563,9 @@ dependencies = [
 [[package]]
 name = "jod-thread"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f52a11f73b88fab829a0e4d9e13ea5982c7ac457c72eb3541d82a4afdfce4ff"
+checksum = "4022656272c3e564a7cdebcaaba6518d844b0d0c1836597196efb5bfeb98bb49"
 [[package]]
 name = "kernel32-sys"
@@ -792,9 +792,9 @@ dependencies = [
 [[package]]
 name = "paste"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8292c1e1e81ddb552c4c90c36af201a0ce7e34995f55f0480f01052f242811c9"
+checksum = "092d791bf7847f70bbd49085489fba25fc2c193571752bff9e36e74e72403932"
 dependencies = [
 "paste-impl",
 "proc-macro-hack",
@@ -802,9 +802,9 @@ dependencies = [
 [[package]]
 name = "paste-impl"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e9c43f2645f06ee452544ad032886a75f3d1797b9487dcadcae9100ba58a51c"
+checksum = "406c23fb4c45cc6f68a9bbabb8ec7bd6f8cfcbd17e9e8f72c2460282f8325729"
 dependencies = [
 "proc-macro-hack",
 "proc-macro2",
@@ -842,15 +842,15 @@ checksum = "74490b50b9fbe561ac330df47c08f3f33073d2d00c150f719147d7c54522fa1b"
 [[package]]
 name = "proc-macro-hack"
-version = "0.5.14"
+version = "0.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcfdefadc3d57ca21cf17990a28ef4c0f7c61383a28cb7604cf4a18e6ede1420"
+checksum = "0d659fe7c6d27f25e9d80a1a094c223f5246f6a6596453e09d7229bf42750b63"
 [[package]]
 name = "proc-macro2"
-version = "1.0.9"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c09721c6781493a2a492a96b5a5bf19b65917fe6728884e7c44dd0c60ca3435"
+checksum = "df246d292ff63439fea9bc8c0a270bed0e390d5ebd4db4ba15aba81111b5abe3"
 dependencies = [
 "unicode-xid",
 ]
@@ -887,18 +887,6 @@ dependencies = [
 ]
 [[package]]
-name = "ra_cargo_watch"
-version = "0.1.0"
-dependencies = [
- "cargo_metadata",
- "crossbeam-channel",
- "insta",
- "log",
- "lsp-types",
- "serde_json",
-]
-[[package]]
 name = "ra_cfg"
 version = "0.1.0"
 dependencies = [
@@ -923,6 +911,19 @@ dependencies = [
 ]
 [[package]]
+name = "ra_flycheck"
+version = "0.1.0"
+dependencies = [
+ "cargo_metadata",
+ "crossbeam-channel",
+ "insta",
+ "jod-thread",
+ "log",
+ "lsp-types",
+ "serde_json",
+]
+[[package]]
 name = "ra_fmt"
 version = "0.1.0"
 dependencies = [
@@ -1074,7 +1075,12 @@ dependencies = [
 name = "ra_proc_macro"
 version = "0.1.0"
 dependencies = [
+ "crossbeam-channel",
+ "jod-thread",
+ "log",
 "ra_tt",
+ "serde",
+ "serde_json",
 ]
 [[package]]
@@ -1095,7 +1101,6 @@ dependencies = [
 "cargo_metadata",
 "log",
 "ra_arena",
- "ra_cargo_watch",
 "ra_cfg",
 "ra_db",
 "ra_proc_macro",
@@ -1294,8 +1299,8 @@ dependencies = [
 "lsp-types",
 "parking_lot",
 "pico-args",
- "ra_cargo_watch",
 "ra_db",
+ "ra_flycheck",
 "ra_hir",
 "ra_hir_def",
 "ra_hir_ty",
@@ -1425,9 +1430,9 @@ dependencies = [
 [[package]]
 name = "serde_json"
-version = "1.0.48"
+version = "1.0.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9371ade75d4c2d6cb154141b9752cf3781ec9c05e0e5cf35060e1e70ee7b9c25"
+checksum = "78a7a12c167809363ec3bd7329fc0a3369056996de43c4b37ef3cd54a6ce4867"
 dependencies = [
 "itoa",
 "ryu",
@@ -1650,9 +1655,9 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 [[package]]
 name = "winapi-util"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ccfbf554c6ad11084fb7517daca16cfdcaccbdadba4fc336f032a8b12c2ad80"
+checksum = "fa515c5163a99cc82bab70fd3bfdd36d827be85de63737b40fcef2ce084a436e"
 dependencies = [
 "winapi 0.3.8",
 ]
diff --git a/crates/ra_arena/src/map.rs b/crates/ra_arena/src/map.rs
index 5e764113d..0f33907c0 100644
--- a/crates/ra_arena/src/map.rs
+++ b/crates/ra_arena/src/map.rs
@@ -14,14 +14,8 @@ pub struct ArenaMap<ID, V> {
 impl<T, V> ArenaMap<Idx<T>, V> {
    pub fn insert(&mut self, id: Idx<T>, t: V) {
        let idx = Self::to_idx(id);
-        if self.v.capacity() <= idx {
-            self.v.reserve(idx + 1 - self.v.capacity());
+        self.v.resize_with((idx + 1).max(self.v.len()), || None);
-        }
-        if self.v.len() <= idx {
-            while self.v.len() <= idx {
-                self.v.push(None);
-            }
-        }
        self.v[idx] = Some(t);
    }
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index add82e5b1..8d1af9933 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -1,15 +1,11 @@
-//! FIXME: write short doc here
 use std::iter;
 use hir::{Adt, HasSource, ModuleDef, Semantics};
 use itertools::Itertools;
 use ra_ide_db::RootDatabase;
+use ra_syntax::ast::{self, make, AstNode, MatchArm, NameOwner, Pat};
 use crate::{Assist, AssistCtx, AssistId};
-use ra_syntax::ast::{self, edit::IndentLevel, make, AstNode, NameOwner};
-use ast::{MatchArm, Pat};
 // Assist: fill_match_arms
 //
@@ -97,10 +93,7 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx) -> Option<Assist> {
    }
    ctx.add_assist(AssistId("fill_match_arms"), "Fill match arms", |edit| {
-        arms.extend(missing_arms);
+        let new_arm_list = match_arm_list.remove_placeholder().append_arms(missing_arms);
-        let indent_level = IndentLevel::from_node(match_arm_list.syntax());
-        let new_arm_list = indent_level.increase_indent(make::match_arm_list(arms));
        edit.target(match_expr.syntax().text_range());
        edit.set_cursor(expr.syntax().text_range().start());
@@ -655,4 +648,93 @@ mod tests {
            "#,
        );
    }
+    #[test]
+    fn fill_match_arms_preserves_comments() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            enum A {
+                One,
+                Two,
+            }
+            fn foo(a: A) {
+                match a {
+                    // foo bar baz<|>
+                    A::One => {}
+                    // This is where the rest should be
+                }
+            }
+            "#,
+            r#"
+            enum A {
+                One,
+                Two,
+            }
+            fn foo(a: A) {
+                match <|>a {
+                    // foo bar baz
+                    A::One => {}
+                    // This is where the rest should be
+                    A::Two => {}
+                }
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn fill_match_arms_preserves_comments_empty() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            enum A {
+                One,
+                Two,
+            }
+            fn foo(a: A) {
+                match a {
+                    // foo bar baz<|>
+                }
+            }
+            "#,
+            r#"
+            enum A {
+                One,
+                Two,
+            }
+            fn foo(a: A) {
+                match <|>a {
+                    // foo bar baz
+                    A::One => {}
+                    A::Two => {}
+                }
+            }
+            "#,
+        );
+    }
+    #[test]
+    fn fill_match_arms_placeholder() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            enum A { One, Two, }
+            fn foo(a: A) {
+                match a<|> {
+                    _ => (),
+                }
+            }
+            "#,
+            r#"
+            enum A { One, Two, }
+            fn foo(a: A) {
+                match <|>a {
+                    A::One => {}
+                    A::Two => {}
+                }
+            }
+            "#,
+        );
+    }
 }
diff --git a/crates/ra_cargo_watch/src/lib.rs b/crates/ra_cargo_watch/src/lib.rs
deleted file mode 100644
index 7c525c430..000000000
--- a/crates/ra_cargo_watch/src/lib.rs
+++ /dev/null
@@ -1,405 +0,0 @@
-//! cargo_check provides the functionality needed to run `cargo check` or
-//! another compatible command (f.x. clippy) in a background thread and provide
-//! LSP diagnostics based on the output of the command.
-use cargo_metadata::Message;
-use crossbeam_channel::{never, select, unbounded, Receiver, RecvError, Sender};
-use lsp_types::{
-    CodeAction, CodeActionOrCommand, Diagnostic, Url, WorkDoneProgress, WorkDoneProgressBegin,
-    WorkDoneProgressEnd, WorkDoneProgressReport,
-};
-use std::{
-    error, fmt,
-    io::{BufRead, BufReader},
-    path::{Path, PathBuf},
-    process::{Command, Stdio},
-    thread::JoinHandle,
-    time::Instant,
-};
-mod conv;
-use crate::conv::{map_rust_diagnostic_to_lsp, MappedRustDiagnostic};
-pub use crate::conv::url_from_path_with_drive_lowercasing;
-#[derive(Clone, Debug)]
-pub struct CheckOptions {
-    pub enable: bool,
-    pub args: Vec<String>,
-    pub command: String,
-    pub all_targets: bool,
-}
-/// CheckWatcher wraps the shared state and communication machinery used for
-/// running `cargo check` (or other compatible command) and providing
-/// diagnostics based on the output.
-/// The spawned thread is shut down when this struct is dropped.
-#[derive(Debug)]
-pub struct CheckWatcher {
-    pub task_recv: Receiver<CheckTask>,
-    cmd_send: Option<Sender<CheckCommand>>,
-    handle: Option<JoinHandle<()>>,
-}
-impl CheckWatcher {
-    pub fn new(options: &CheckOptions, workspace_root: PathBuf) -> CheckWatcher {
-        let options = options.clone();
-        let (task_send, task_recv) = unbounded::<CheckTask>();
-        let (cmd_send, cmd_recv) = unbounded::<CheckCommand>();
-        let handle = std::thread::spawn(move || {
-            let mut check = CheckWatcherThread::new(options, workspace_root);
-            check.run(&task_send, &cmd_recv);
-        });
-        CheckWatcher { task_recv, cmd_send: Some(cmd_send), handle: Some(handle) }
-    }
-    /// Returns a CheckWatcher that doesn't actually do anything
-    pub fn dummy() -> CheckWatcher {
-        CheckWatcher { task_recv: never(), cmd_send: None, handle: None }
-    }
-    /// Schedule a re-start of the cargo check worker.
-    pub fn update(&self) {
-        if let Some(cmd_send) = &self.cmd_send {
-            cmd_send.send(CheckCommand::Update).unwrap();
-        }
-    }
-}
-impl std::ops::Drop for CheckWatcher {
-    fn drop(&mut self) {
-        if let Some(handle) = self.handle.take() {
-            // Take the sender out of the option
-            let cmd_send = self.cmd_send.take();
-            // Dropping the sender finishes the thread loop
-            drop(cmd_send);
-            // Join the thread, it should finish shortly. We don't really care
-            // whether it panicked, so it is safe to ignore the result
-            let _ = handle.join();
-        }
-    }
-}
-#[derive(Debug)]
-pub enum CheckTask {
-    /// Request a clearing of all cached diagnostics from the check watcher
-    ClearDiagnostics,
-    /// Request adding a diagnostic with fixes included to a file
-    AddDiagnostic { url: Url, diagnostic: Diagnostic, fixes: Vec<CodeActionOrCommand> },
-    /// Request check progress notification to client
-    Status(WorkDoneProgress),
-}
-pub enum CheckCommand {
-    /// Request re-start of check thread
-    Update,
-}
-struct CheckWatcherThread {
-    options: CheckOptions,
-    workspace_root: PathBuf,
-    watcher: WatchThread,
-    last_update_req: Option<Instant>,
-}
-impl CheckWatcherThread {
-    fn new(options: CheckOptions, workspace_root: PathBuf) -> CheckWatcherThread {
-        CheckWatcherThread {
-            options,
-            workspace_root,
-            watcher: WatchThread::dummy(),
-            last_update_req: None,
-        }
-    }
-    fn run(&mut self, task_send: &Sender<CheckTask>, cmd_recv: &Receiver<CheckCommand>) {
-        loop {
-            select! {
-                recv(&cmd_recv) -> cmd => match cmd {
-                    Ok(cmd) => self.handle_command(cmd),
-                    Err(RecvError) => {
-                        // Command channel has closed, so shut down
-                        break;
-                    },
-                },
-                recv(self.watcher.message_recv) -> msg => match msg {
-                    Ok(msg) => self.handle_message(msg, task_send),
-                    Err(RecvError) => {
-                        // Watcher finished, replace it with a never channel to
-                        // avoid busy-waiting.
-                        std::mem::replace(&mut self.watcher.message_recv, never());
-                    },
-                }
-            };
-            if self.should_recheck() {
-                self.last_update_req.take();
-                task_send.send(CheckTask::ClearDiagnostics).unwrap();
-                // Replace with a dummy watcher first so we drop the original and wait for completion
-                std::mem::replace(&mut self.watcher, WatchThread::dummy());
-                // Then create the actual new watcher
-                self.watcher = WatchThread::new(&self.options, &self.workspace_root);
-            }
-        }
-    }
-    fn should_recheck(&mut self) -> bool {
-        if let Some(_last_update_req) = &self.last_update_req {
-            // We currently only request an update on save, as we need up to
-            // date source on disk for cargo check to do it's magic, so we
-            // don't really need to debounce the requests at this point.
-            return true;
-        }
-        false
-    }
-    fn handle_command(&mut self, cmd: CheckCommand) {
-        match cmd {
-            CheckCommand::Update => self.last_update_req = Some(Instant::now()),
-        }
-    }
-    fn handle_message(&self, msg: CheckEvent, task_send: &Sender<CheckTask>) {
-        match msg {
-            CheckEvent::Begin => {
-                task_send
-                    .send(CheckTask::Status(WorkDoneProgress::Begin(WorkDoneProgressBegin {
-                        title: "Running 'cargo check'".to_string(),
-                        cancellable: Some(false),
-                        message: None,
-                        percentage: None,
-                    })))
-                    .unwrap();
-            }
-            CheckEvent::End => {
-                task_send
-                    .send(CheckTask::Status(WorkDoneProgress::End(WorkDoneProgressEnd {
-                        message: None,
-                    })))
-                    .unwrap();
-            }
-            CheckEvent::Msg(Message::CompilerArtifact(msg)) => {
-                task_send
-                    .send(CheckTask::Status(WorkDoneProgress::Report(WorkDoneProgressReport {
-                        cancellable: Some(false),
-                        message: Some(msg.target.name),
-                        percentage: None,
-                    })))
-                    .unwrap();
-            }
-            CheckEvent::Msg(Message::CompilerMessage(msg)) => {
-                let map_result = map_rust_diagnostic_to_lsp(&msg.message, &self.workspace_root);
-                if map_result.is_empty() {
-                    return;
-                }
-                for MappedRustDiagnostic { location, diagnostic, fixes } in map_result {
-                    let fixes = fixes
-                        .into_iter()
-                        .map(|fix| {
-                            CodeAction { diagnostics: Some(vec![diagnostic.clone()]), ..fix }.into()
-                        })
-                        .collect();
-                    task_send
-                        .send(CheckTask::AddDiagnostic { url: location.uri, diagnostic, fixes })
-                        .unwrap();
-                }
-            }
-            CheckEvent::Msg(Message::BuildScriptExecuted(_msg)) => {}
-            CheckEvent::Msg(Message::Unknown) => {}
-        }
-    }
-}
-#[derive(Debug)]
-pub struct DiagnosticWithFixes {
-    diagnostic: Diagnostic,
-    fixes: Vec<CodeAction>,
-}
-/// WatchThread exists to wrap around the communication needed to be able to
-/// run `cargo check` without blocking. Currently the Rust standard library
-/// doesn't provide a way to read sub-process output without blocking, so we
-/// have to wrap sub-processes output handling in a thread and pass messages
-/// back over a channel.
-/// The correct way to dispose of the thread is to drop it, on which the
-/// sub-process will be killed, and the thread will be joined.
-struct WatchThread {
-    handle: Option<JoinHandle<()>>,
-    message_recv: Receiver<CheckEvent>,
-}
-enum CheckEvent {
-    Begin,
-    Msg(cargo_metadata::Message),
-    End,
-}
-#[derive(Debug)]
-pub struct CargoError(String);
-impl fmt::Display for CargoError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Cargo failed: {}", self.0)
-    }
-}
-impl error::Error for CargoError {}
-pub fn run_cargo(
-    args: &[String],
-    current_dir: Option<&Path>,
-    on_message: &mut dyn FnMut(cargo_metadata::Message) -> bool,
-) -> Result<(), CargoError> {
-    let mut command = Command::new("cargo");
-    if let Some(current_dir) = current_dir {
-        command.current_dir(current_dir);
-    }
-    let mut child = command
-        .args(args)
-        .stdout(Stdio::piped())
-        .stderr(Stdio::null())
-        .stdin(Stdio::null())
-        .spawn()
-        .expect("couldn't launch cargo");
-    // We manually read a line at a time, instead of using serde's
-    // stream deserializers, because the deserializer cannot recover
-    // from an error, resulting in it getting stuck, because we try to
-    // be resillient against failures.
-    //
-    // Because cargo only outputs one JSON object per line, we can
-    // simply skip a line if it doesn't parse, which just ignores any
-    // erroneus output.
-    let stdout = BufReader::new(child.stdout.take().unwrap());
-    let mut read_at_least_one_message = false;
-    for line in stdout.lines() {
-        let line = match line {
-            Ok(line) => line,
-            Err(err) => {
-                log::error!("Couldn't read line from cargo: {}", err);
-                continue;
-            }
-        };
-        let message = serde_json::from_str::<cargo_metadata::Message>(&line);
-        let message = match message {
-            Ok(message) => message,
-            Err(err) => {
-                log::error!("Invalid json from cargo check, ignoring ({}): {:?} ", err, line);
-                continue;
-            }
-        };
-        read_at_least_one_message = true;
-        if !on_message(message) {
-            break;
-        }
-    }
-    // It is okay to ignore the result, as it only errors if the process is already dead
-    let _ = child.kill();
-    let err_msg = match child.wait() {
-        Ok(exit_code) if !exit_code.success() && !read_at_least_one_message => {
-            // FIXME: Read the stderr to display the reason, see `read2()` reference in PR comment:
-            // https://github.com/rust-analyzer/rust-analyzer/pull/3632#discussion_r395605298
-            format!(
-                "the command produced no valid metadata (exit code: {:?}): cargo {}",
-                exit_code,
-                args.join(" ")
-            )
-        }
-        Err(err) => format!("io error: {:?}", err),
-        Ok(_) => return Ok(()),
-    };
-    Err(CargoError(err_msg))
-}
-impl WatchThread {
-    fn dummy() -> WatchThread {
-        WatchThread { handle: None, message_recv: never() }
-    }
-    fn new(options: &CheckOptions, workspace_root: &Path) -> WatchThread {
-        let mut args: Vec<String> = vec![
-            options.command.clone(),
-            "--workspace".to_string(),
-            "--message-format=json".to_string(),
-            "--manifest-path".to_string(),
-            format!("{}/Cargo.toml", workspace_root.display()),
-        ];
-        if options.all_targets {
-            args.push("--all-targets".to_string());
-        }
-        args.extend(options.args.iter().cloned());
-        let (message_send, message_recv) = unbounded();
-        let workspace_root = workspace_root.to_owned();
-        let handle = if options.enable {
-            Some(std::thread::spawn(move || {
-                // If we trigger an error here, we will do so in the loop instead,
-                // which will break out of the loop, and continue the shutdown
-                let _ = message_send.send(CheckEvent::Begin);
-                let res = run_cargo(&args, Some(&workspace_root), &mut |message| {
-                    // Skip certain kinds of messages to only spend time on what's useful
-                    match &message {
-                        Message::CompilerArtifact(artifact) if artifact.fresh => return true,
-                        Message::BuildScriptExecuted(_) => return true,
-                        Message::Unknown => return true,
-                        _ => {}
-                    }
-                    // if the send channel was closed, we want to shutdown
-                    message_send.send(CheckEvent::Msg(message)).is_ok()
-                });
-                if let Err(err) = res {
-                    // FIXME: make the `message_send` to be `Sender<Result<CheckEvent, CargoError>>`
-                    // to display user-caused misconfiguration errors instead of just logging them here
-                    log::error!("Cargo watcher failed {:?}", err);
-                }
-                // We can ignore any error here, as we are already in the progress
-                // of shutting down.
-                let _ = message_send.send(CheckEvent::End);
-            }))
-        } else {
-            None
-        };
-        WatchThread { handle, message_recv }
-    }
-}
-impl std::ops::Drop for WatchThread {
-    fn drop(&mut self) {
-        if let Some(handle) = self.handle.take() {
-            // Replace our reciever with dummy one, so we can drop and close the
-            // one actually communicating with the thread
-            let recv = std::mem::replace(&mut self.message_recv, never());
-            // Dropping the original reciever initiates thread sub-process shutdown
-            drop(recv);
-            // Join the thread, it should finish shortly. We don't really care
-            // whether it panicked, so it is safe to ignore the result
-            let _ = handle.join();
-        }
-    }
-}
diff --git a/crates/ra_cargo_watch/Cargo.toml b/crates/ra_flycheck/Cargo.toml
index 741345a21..c9a9ddc12 100644
--- a/crates/ra_cargo_watch/Cargo.toml
+++ b/crates/ra_flycheck/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 edition = "2018"
-name = "ra_cargo_watch"
+name = "ra_flycheck"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
@@ -10,6 +10,7 @@ lsp-types = { version = "0.73.0", features = ["proposed"] }
 log = "0.4.8"
 cargo_metadata = "0.9.1"
 serde_json = "1.0.48"
+jod-thread = "0.1.1"
 [dev-dependencies]
 insta = "0.15.0"
diff --git a/crates/ra_cargo_watch/src/conv.rs b/crates/ra_flycheck/src/conv.rs
index 817543deb..817543deb 100644
--- a/crates/ra_cargo_watch/src/conv.rs
+++ b/crates/ra_flycheck/src/conv.rs
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_clippy_pass_by_ref.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_clippy_pass_by_ref.snap
index a59fa84fa..4c9db0385 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_clippy_pass_by_ref.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_clippy_pass_by_ref.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_handles_macro_location.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_handles_macro_location.snap
index 61ae0c9ae..7cde4d867 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_handles_macro_location.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_handles_macro_location.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_macro_compiler_error.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_macro_compiler_error.snap
index 641da1a58..1cc37e087 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_macro_compiler_error.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_macro_compiler_error.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_multi_line_fix.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_multi_line_fix.snap
index 0557a2e79..615ed8378 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_multi_line_fix.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_multi_line_fix.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_incompatible_type_for_trait.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_incompatible_type_for_trait.snap
index 754bc33a4..0df0fce18 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_incompatible_type_for_trait.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_incompatible_type_for_trait.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_mismatched_type.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_mismatched_type.snap
index 78b7f7cc8..28ebcb3b3 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_mismatched_type.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_mismatched_type.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_unused_variable.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_unused_variable.snap
index 5989ed202..5e0873281 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_unused_variable.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_unused_variable.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_wrong_number_of_parameters.snap b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_wrong_number_of_parameters.snap
index e34b546dc..e500d3cd6 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_rustc_wrong_number_of_parameters.snap
+++ b/crates/ra_flycheck/src/conv/snapshots/ra_flycheck__conv__test__snap_rustc_wrong_number_of_parameters.snap
@@ -1,5 +1,5 @@
 ---
-source: crates/ra_cargo_watch/src/conv/test.rs
+source: crates/ra_flycheck/src/conv/test.rs
 expression: diag
 ---
 [
diff --git a/crates/ra_cargo_watch/src/conv/test.rs b/crates/ra_flycheck/src/conv/test.rs
index 4e81455ca..4e81455ca 100644
--- a/crates/ra_cargo_watch/src/conv/test.rs
+++ b/crates/ra_flycheck/src/conv/test.rs
diff --git a/crates/ra_flycheck/src/lib.rs b/crates/ra_flycheck/src/lib.rs
new file mode 100644
index 000000000..b54a30ab8
--- /dev/null
+++ b/crates/ra_flycheck/src/lib.rs
@@ -0,0 +1,340 @@
+//! cargo_check provides the functionality needed to run `cargo check` or
+//! another compatible command (f.x. clippy) in a background thread and provide
+//! LSP diagnostics based on the output of the command.
+mod conv;
+use std::{
+    env,
+    io::{self, BufRead, BufReader},
+    path::PathBuf,
+    process::{Command, Stdio},
+    time::Instant,
+};
+use cargo_metadata::Message;
+use crossbeam_channel::{never, select, unbounded, Receiver, RecvError, Sender};
+use lsp_types::{
+    CodeAction, CodeActionOrCommand, Diagnostic, Url, WorkDoneProgress, WorkDoneProgressBegin,
+    WorkDoneProgressEnd, WorkDoneProgressReport,
+};
+use crate::conv::{map_rust_diagnostic_to_lsp, MappedRustDiagnostic};
+pub use crate::conv::url_from_path_with_drive_lowercasing;
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum FlycheckConfig {
+    CargoCommand { command: String, all_targets: bool, extra_args: Vec<String> },
+    CustomCommand { command: String, args: Vec<String> },
+}
+/// Flycheck wraps the shared state and communication machinery used for
+/// running `cargo check` (or other compatible command) and providing
+/// diagnostics based on the output.
+/// The spawned thread is shut down when this struct is dropped.
+#[derive(Debug)]
+pub struct Flycheck {
+    // XXX: drop order is significant
+    cmd_send: Sender<CheckCommand>,
+    handle: jod_thread::JoinHandle<()>,
+    pub task_recv: Receiver<CheckTask>,
+}
+impl Flycheck {
+    pub fn new(config: FlycheckConfig, workspace_root: PathBuf) -> Flycheck {
+        let (task_send, task_recv) = unbounded::<CheckTask>();
+        let (cmd_send, cmd_recv) = unbounded::<CheckCommand>();
+        let handle = jod_thread::spawn(move || {
+            FlycheckThread::new(config, workspace_root).run(&task_send, &cmd_recv);
+        });
+        Flycheck { task_recv, cmd_send, handle }
+    }
+    /// Schedule a re-start of the cargo check worker.
+    pub fn update(&self) {
+        self.cmd_send.send(CheckCommand::Update).unwrap();
+    }
+}
+#[derive(Debug)]
+pub enum CheckTask {
+    /// Request a clearing of all cached diagnostics from the check watcher
+    ClearDiagnostics,
+    /// Request adding a diagnostic with fixes included to a file
+    AddDiagnostic { url: Url, diagnostic: Diagnostic, fixes: Vec<CodeActionOrCommand> },
+    /// Request check progress notification to client
+    Status(WorkDoneProgress),
+}
+pub enum CheckCommand {
+    /// Request re-start of check thread
+    Update,
+}
+struct FlycheckThread {
+    config: FlycheckConfig,
+    workspace_root: PathBuf,
+    last_update_req: Option<Instant>,
+    // XXX: drop order is significant
+    message_recv: Receiver<CheckEvent>,
+    /// WatchThread exists to wrap around the communication needed to be able to
+    /// run `cargo check` without blocking. Currently the Rust standard library
+    /// doesn't provide a way to read sub-process output without blocking, so we
+    /// have to wrap sub-processes output handling in a thread and pass messages
+    /// back over a channel.
+    check_process: Option<jod_thread::JoinHandle<()>>,
+}
+impl FlycheckThread {
+    fn new(config: FlycheckConfig, workspace_root: PathBuf) -> FlycheckThread {
+        FlycheckThread {
+            config,
+            workspace_root,
+            last_update_req: None,
+            message_recv: never(),
+            check_process: None,
+        }
+    }
+    fn run(&mut self, task_send: &Sender<CheckTask>, cmd_recv: &Receiver<CheckCommand>) {
+        // If we rerun the thread, we need to discard the previous check results first
+        self.clean_previous_results(task_send);
+        loop {
+            select! {
+                recv(&cmd_recv) -> cmd => match cmd {
+                    Ok(cmd) => self.handle_command(cmd),
+                    Err(RecvError) => {
+                        // Command channel has closed, so shut down
+                        break;
+                    },
+                },
+                recv(self.message_recv) -> msg => match msg {
+                    Ok(msg) => self.handle_message(msg, task_send),
+                    Err(RecvError) => {
+                        // Watcher finished, replace it with a never channel to
+                        // avoid busy-waiting.
+                        self.message_recv = never();
+                        self.check_process = None;
+                    },
+                }
+            };
+            if self.should_recheck() {
+                self.last_update_req = None;
+                task_send.send(CheckTask::ClearDiagnostics).unwrap();
+                self.restart_check_process();
+            }
+        }
+    }
+    fn clean_previous_results(&self, task_send: &Sender<CheckTask>) {
+        task_send.send(CheckTask::ClearDiagnostics).unwrap();
+        task_send
+            .send(CheckTask::Status(WorkDoneProgress::End(WorkDoneProgressEnd { message: None })))
+            .unwrap();
+    }
+    fn should_recheck(&mut self) -> bool {
+        if let Some(_last_update_req) = &self.last_update_req {
+            // We currently only request an update on save, as we need up to
+            // date source on disk for cargo check to do it's magic, so we
+            // don't really need to debounce the requests at this point.
+            return true;
+        }
+        false
+    }
+    fn handle_command(&mut self, cmd: CheckCommand) {
+        match cmd {
+            CheckCommand::Update => self.last_update_req = Some(Instant::now()),
+        }
+    }
+    fn handle_message(&self, msg: CheckEvent, task_send: &Sender<CheckTask>) {
+        match msg {
+            CheckEvent::Begin => {
+                task_send
+                    .send(CheckTask::Status(WorkDoneProgress::Begin(WorkDoneProgressBegin {
+                        title: "Running 'cargo check'".to_string(),
+                        cancellable: Some(false),
+                        message: None,
+                        percentage: None,
+                    })))
+                    .unwrap();
+            }
+            CheckEvent::End => {
+                task_send
+                    .send(CheckTask::Status(WorkDoneProgress::End(WorkDoneProgressEnd {
+                        message: None,
+                    })))
+                    .unwrap();
+            }
+            CheckEvent::Msg(Message::CompilerArtifact(msg)) => {
+                task_send
+                    .send(CheckTask::Status(WorkDoneProgress::Report(WorkDoneProgressReport {
+                        cancellable: Some(false),
+                        message: Some(msg.target.name),
+                        percentage: None,
+                    })))
+                    .unwrap();
+            }
+            CheckEvent::Msg(Message::CompilerMessage(msg)) => {
+                let map_result = map_rust_diagnostic_to_lsp(&msg.message, &self.workspace_root);
+                if map_result.is_empty() {
+                    return;
+                }
+                for MappedRustDiagnostic { location, diagnostic, fixes } in map_result {
+                    let fixes = fixes
+                        .into_iter()
+                        .map(|fix| {
+                            CodeAction { diagnostics: Some(vec![diagnostic.clone()]), ..fix }.into()
+                        })
+                        .collect();
+                    task_send
+                        .send(CheckTask::AddDiagnostic { url: location.uri, diagnostic, fixes })
+                        .unwrap();
+                }
+            }
+            CheckEvent::Msg(Message::BuildScriptExecuted(_msg)) => {}
+            CheckEvent::Msg(Message::Unknown) => {}
+        }
+    }
+    fn restart_check_process(&mut self) {
+        // First, clear and cancel the old thread
+        self.message_recv = never();
+        self.check_process = None;
+        let mut cmd = match &self.config {
+            FlycheckConfig::CargoCommand { command, all_targets, extra_args } => {
+                let mut cmd = Command::new(cargo_binary());
+                cmd.arg(command);
+                cmd.args(&["--workspace", "--message-format=json", "--manifest-path"]);
+                cmd.arg(self.workspace_root.join("Cargo.toml"));
+                if *all_targets {
+                    cmd.arg("--all-targets");
+                }
+                cmd.args(extra_args);
+                cmd
+            }
+            FlycheckConfig::CustomCommand { command, args } => {
+                let mut cmd = Command::new(command);
+                cmd.args(args);
+                cmd
+            }
+        };
+        cmd.current_dir(&self.workspace_root);
+        let (message_send, message_recv) = unbounded();
+        self.message_recv = message_recv;
+        self.check_process = Some(jod_thread::spawn(move || {
+            // If we trigger an error here, we will do so in the loop instead,
+            // which will break out of the loop, and continue the shutdown
+            let _ = message_send.send(CheckEvent::Begin);
+            let res = run_cargo(cmd, &mut |message| {
+                // Skip certain kinds of messages to only spend time on what's useful
+                match &message {
+                    Message::CompilerArtifact(artifact) if artifact.fresh => return true,
+                    Message::BuildScriptExecuted(_) => return true,
+                    Message::Unknown => return true,
+                    _ => {}
+                }
+                // if the send channel was closed, we want to shutdown
+                message_send.send(CheckEvent::Msg(message)).is_ok()
+            });
+            if let Err(err) = res {
+                // FIXME: make the `message_send` to be `Sender<Result<CheckEvent, CargoError>>`
+                // to display user-caused misconfiguration errors instead of just logging them here
+                log::error!("Cargo watcher failed {:?}", err);
+            }
+            // We can ignore any error here, as we are already in the progress
+            // of shutting down.
+            let _ = message_send.send(CheckEvent::End);
+        }))
+    }
+}
+#[derive(Debug)]
+pub struct DiagnosticWithFixes {
+    diagnostic: Diagnostic,
+    fixes: Vec<CodeAction>,
+}
+enum CheckEvent {
+    Begin,
+    Msg(cargo_metadata::Message),
+    End,
+}
+fn run_cargo(
+    mut command: Command,
+    on_message: &mut dyn FnMut(cargo_metadata::Message) -> bool,
+) -> io::Result<()> {
+    let mut child =
+        command.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null()).spawn()?;
+    // We manually read a line at a time, instead of using serde's
+    // stream deserializers, because the deserializer cannot recover
+    // from an error, resulting in it getting stuck, because we try to
+    // be resillient against failures.
+    //
+    // Because cargo only outputs one JSON object per line, we can
+    // simply skip a line if it doesn't parse, which just ignores any
+    // erroneus output.
+    let stdout = BufReader::new(child.stdout.take().unwrap());
+    let mut read_at_least_one_message = false;
+    for line in stdout.lines() {
+        let line = line?;
+        let message = serde_json::from_str::<cargo_metadata::Message>(&line);
+        let message = match message {
+            Ok(message) => message,
+            Err(err) => {
+                log::error!("Invalid json from cargo check, ignoring ({}): {:?} ", err, line);
+                continue;
+            }
+        };
+        read_at_least_one_message = true;
+        if !on_message(message) {
+            break;
+        }
+    }
+    // It is okay to ignore the result, as it only errors if the process is already dead
+    let _ = child.kill();
+    let exit_status = child.wait()?;
+    if !exit_status.success() && !read_at_least_one_message {
+        // FIXME: Read the stderr to display the reason, see `read2()` reference in PR comment:
+        // https://github.com/rust-analyzer/rust-analyzer/pull/3632#discussion_r395605298
+        return Err(io::Error::new(
+            io::ErrorKind::Other,
+            format!(
+                "the command produced no valid metadata (exit code: {:?}): {:?}",
+                exit_status, command
+            ),
+        ));
+    }
+    Ok(())
+}
+fn cargo_binary() -> String {
+    env::var("CARGO").unwrap_or_else(|_| "cargo".to_string())
+}
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index e8443dde8..28c570c76 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -417,26 +417,7 @@ impl ExprCollector<'_> {
                }
            }
-            ast::Expr::Literal(e) => {
+            ast::Expr::Literal(e) => self.alloc_expr(Expr::Literal(e.kind().into()), syntax_ptr),
-                let lit = match e.kind() {
-                    LiteralKind::IntNumber { suffix } => {
-                        let known_name = suffix.and_then(|it| BuiltinInt::from_suffix(&it));
-                        Literal::Int(Default::default(), known_name)
-                    }
-                    LiteralKind::FloatNumber { suffix } => {
-                        let known_name = suffix.and_then(|it| BuiltinFloat::from_suffix(&it));
-                        Literal::Float(Default::default(), known_name)
-                    }
-                    LiteralKind::ByteString => Literal::ByteString(Default::default()),
-                    LiteralKind::String => Literal::String(Default::default()),
-                    LiteralKind::Byte => Literal::Int(Default::default(), Some(BuiltinInt::U8)),
-                    LiteralKind::Bool => Literal::Bool(Default::default()),
-                    LiteralKind::Char => Literal::Char(Default::default()),
-                };
-                self.alloc_expr(Expr::Literal(lit), syntax_ptr)
-            }
            ast::Expr::IndexExpr(e) => {
                let base = self.collect_expr_opt(e.base());
                let index = self.collect_expr_opt(e.index());
@@ -679,10 +660,19 @@ impl ExprCollector<'_> {
                    suffix: suffix.into_iter().map(|p| self.collect_pat(p)).collect(),
                }
            }
+            ast::Pat::LiteralPat(lit) => {
+                if let Some(ast_lit) = lit.literal() {
+                    let expr = Expr::Literal(ast_lit.kind().into());
+                    let expr_ptr = AstPtr::new(&ast::Expr::Literal(ast_lit));
+                    let expr_id = self.alloc_expr(expr, expr_ptr);
+                    Pat::Lit(expr_id)
+                } else {
+                    Pat::Missing
+                }
+            }
            // FIXME: implement
            ast::Pat::BoxPat(_) => Pat::Missing,
-            ast::Pat::LiteralPat(_) => Pat::Missing,
            ast::Pat::RangePat(_) => Pat::Missing,
        };
        let ptr = AstPtr::new(&pat);
@@ -741,3 +731,25 @@ impl From<ast::BinOp> for BinaryOp {
        }
    }
 }
+impl From<ast::LiteralKind> for Literal {
+    fn from(ast_lit_kind: ast::LiteralKind) -> Self {
+        match ast_lit_kind {
+            LiteralKind::IntNumber { suffix } => {
+                let known_name = suffix.and_then(|it| BuiltinInt::from_suffix(&it));
+                Literal::Int(Default::default(), known_name)
+            }
+            LiteralKind::FloatNumber { suffix } => {
+                let known_name = suffix.and_then(|it| BuiltinFloat::from_suffix(&it));
+                Literal::Float(Default::default(), known_name)
+            }
+            LiteralKind::ByteString => Literal::ByteString(Default::default()),
+            LiteralKind::String => Literal::String(Default::default()),
+            LiteralKind::Byte => Literal::Int(Default::default(), Some(BuiltinInt::U8)),
+            LiteralKind::Bool(val) => Literal::Bool(val),
+            LiteralKind::Char => Literal::Char(Default::default()),
+        }
+    }
+}
diff --git a/crates/ra_hir_expand/src/proc_macro.rs b/crates/ra_hir_expand/src/proc_macro.rs
index 4d270e0de..97d1208ec 100644
--- a/crates/ra_hir_expand/src/proc_macro.rs
+++ b/crates/ra_hir_expand/src/proc_macro.rs
@@ -9,6 +9,15 @@ pub struct ProcMacroExpander {
    proc_macro_id: ProcMacroId,
 }
+macro_rules! err {
+    ($fmt:literal, $($tt:tt),*) => {
+        mbe::ExpandError::ProcMacroError(tt::ExpansionError::Unknown(format!($fmt, $($tt),*)))
+    };
+    ($fmt:literal) => {
+        mbe::ExpandError::ProcMacroError(tt::ExpansionError::Unknown($fmt.to_string()))
+    }
+}
 impl ProcMacroExpander {
    pub fn new(krate: CrateId, proc_macro_id: ProcMacroId) -> ProcMacroExpander {
        ProcMacroExpander { krate, proc_macro_id }
@@ -25,8 +34,24 @@ impl ProcMacroExpander {
            .proc_macro
            .get(self.proc_macro_id.0 as usize)
            .clone()
-            .ok_or_else(|| mbe::ExpandError::ConversionError)?;
+            .ok_or_else(|| err!("No derive macro found."))?;
+        let tt = remove_derive_atr(tt, &proc_macro.name)
+            .ok_or_else(|| err!("Fail to remove derive for custom derive"))?;
        proc_macro.expander.expand(&tt, None).map_err(mbe::ExpandError::from)
    }
 }
+fn remove_derive_atr(tt: &tt::Subtree, _name: &str) -> Option<tt::Subtree> {
+    // FIXME: proper handle the remove derive
+    // We assume the first 2 tokens are #[derive(name)]
+    if tt.token_trees.len() > 2 {
+        let mut tt = tt.clone();
+        tt.token_trees.remove(0);
+        tt.token_trees.remove(0);
+        return Some(tt);
+    }
+    None
+}
diff --git a/crates/ra_hir_ty/src/display.rs b/crates/ra_hir_ty/src/display.rs
index a6ef44a31..13ecd537a 100644
--- a/crates/ra_hir_ty/src/display.rs
+++ b/crates/ra_hir_ty/src/display.rs
@@ -159,20 +159,13 @@ impl HirDisplay for ApplicationTy {
            }
            TypeCtor::FnDef(def) => {
                let sig = f.db.callable_item_signature(def).subst(&self.parameters);
-                let name = match def {
+                match def {
-                    CallableDef::FunctionId(ff) => f.db.function_data(ff).name.clone(),
+                    CallableDef::FunctionId(ff) => write!(f, "fn {}", f.db.function_data(ff).name)?,
-                    CallableDef::StructId(s) => f.db.struct_data(s).name.clone(),
+                    CallableDef::StructId(s) => write!(f, "{}", f.db.struct_data(s).name)?,
                    CallableDef::EnumVariantId(e) => {
-                        let enum_data = f.db.enum_data(e.parent);
+                        write!(f, "{}", f.db.enum_data(e.parent).variants[e.local_id].name)?
-                        enum_data.variants[e.local_id].name.clone()
                    }
                };
-                match def {
-                    CallableDef::FunctionId(_) => write!(f, "fn {}", name)?,
-                    CallableDef::StructId(_) | CallableDef::EnumVariantId(_) => {
-                        write!(f, "{}", name)?
-                    }
-                }
                if self.parameters.len() > 0 {
                    let generics = generics(f.db.upcast(), def.into());
                    let (parent_params, self_param, type_params, _impl_trait_params) =
@@ -197,8 +190,6 @@ impl HirDisplay for ApplicationTy {
                };
                write!(f, "{}", name)?;
                if self.parameters.len() > 0 {
-                    write!(f, "<")?;
                    let mut non_default_parameters = Vec::with_capacity(self.parameters.len());
                    let parameters_to_write = if f.omit_verbose_types() {
                        match self
@@ -207,8 +198,8 @@ impl HirDisplay for ApplicationTy {
                            .map(|generic_def_id| f.db.generic_defaults(generic_def_id))
                            .filter(|defaults| !defaults.is_empty())
                        {
-                            Option::None => self.parameters.0.as_ref(),
+                            None => self.parameters.0.as_ref(),
-                            Option::Some(default_parameters) => {
+                            Some(default_parameters) => {
                                for (i, parameter) in self.parameters.iter().enumerate() {
                                    match (parameter, default_parameters.get(i)) {
                                        (&Ty::Unknown, _) | (_, None) => {
@@ -228,7 +219,7 @@ impl HirDisplay for ApplicationTy {
                    } else {
                        self.parameters.0.as_ref()
                    };
+                    write!(f, "<")?;
                    f.write_joined(parameters_to_write, ", ")?;
                    write!(f, ">")?;
                }
@@ -238,9 +229,9 @@ impl HirDisplay for ApplicationTy {
                    AssocContainerId::TraitId(it) => it,
                    _ => panic!("not an associated type"),
                };
-                let trait_name = f.db.trait_data(trait_).name.clone();
+                let trait_ = f.db.trait_data(trait_);
-                let name = f.db.type_alias_data(type_alias).name.clone();
+                let type_alias = f.db.type_alias_data(type_alias);
-                write!(f, "{}::{}", trait_name, name)?;
+                write!(f, "{}::{}", trait_.name, type_alias.name)?;
                if self.parameters.len() > 0 {
                    write!(f, "<")?;
                    f.write_joined(&*self.parameters.0, ", ")?;
@@ -273,8 +264,8 @@ impl HirDisplay for ProjectionTy {
            return write!(f, "{}", TYPE_HINT_TRUNCATION);
        }
-        let trait_name = f.db.trait_data(self.trait_(f.db)).name.clone();
+        let trait_ = f.db.trait_data(self.trait_(f.db));
-        write!(f, "<{} as {}", self.parameters[0].display(f.db), trait_name,)?;
+        write!(f, "<{} as {}", self.parameters[0].display(f.db), trait_.name)?;
        if self.parameters.len() > 1 {
            write!(f, "<")?;
            f.write_joined(&self.parameters[1..], ", ")?;
@@ -319,7 +310,7 @@ impl HirDisplay for Ty {
                    Ty::Opaque(_) => write!(f, "impl ")?,
                    _ => unreachable!(),
                };
-                write_bounds_like_dyn_trait(&predicates, f)?;
+                write_bounds_like_dyn_trait(predicates, f)?;
            }
            Ty::Unknown => write!(f, "{{unknown}}")?,
            Ty::Infer(..) => write!(f, "_")?,
@@ -352,7 +343,7 @@ fn write_bounds_like_dyn_trait(
                // We assume that the self type is $0 (i.e. the
                // existential) here, which is the only thing that's
                // possible in actual Rust, and hence don't print it
-                write!(f, "{}", f.db.trait_data(trait_ref.trait_).name.clone())?;
+                write!(f, "{}", f.db.trait_data(trait_ref.trait_).name)?;
                if trait_ref.substs.len() > 1 {
                    write!(f, "<")?;
                    f.write_joined(&trait_ref.substs[1..], ", ")?;
@@ -369,9 +360,8 @@ fn write_bounds_like_dyn_trait(
                    write!(f, "<")?;
                    angle_open = true;
                }
-                let name =
+                let type_alias = f.db.type_alias_data(projection_pred.projection_ty.associated_ty);
-                    f.db.type_alias_data(projection_pred.projection_ty.associated_ty).name.clone();
+                write!(f, "{} = ", type_alias.name)?;
-                write!(f, "{} = ", name)?;
                projection_pred.ty.hir_fmt(f)?;
            }
            GenericPredicate::Error => {
@@ -405,7 +395,7 @@ impl TraitRef {
        } else {
            write!(f, ": ")?;
        }
-        write!(f, "{}", f.db.trait_data(self.trait_).name.clone())?;
+        write!(f, "{}", f.db.trait_data(self.trait_).name)?;
        if self.substs.len() > 1 {
            write!(f, "<")?;
            f.write_joined(&self.substs[1..], ", ")?;
diff --git a/crates/ra_hir_ty/src/infer/pat.rs b/crates/ra_hir_ty/src/infer/pat.rs
index baed6225b..86acd27f8 100644
--- a/crates/ra_hir_ty/src/infer/pat.rs
+++ b/crates/ra_hir_ty/src/infer/pat.rs
@@ -11,7 +11,7 @@ use hir_def::{
 use hir_expand::name::Name;
 use test_utils::tested_by;
-use super::{BindingMode, InferenceContext};
+use super::{BindingMode, Expectation, InferenceContext};
 use crate::{utils::variant_data, Substs, Ty, TypeCtor};
 impl<'a> InferenceContext<'a> {
@@ -198,7 +198,14 @@ impl<'a> InferenceContext<'a> {
                Ty::apply_one(container_ty, elem_ty)
            }
-            _ => Ty::Unknown,
+            Pat::Wild => expected.clone(),
+            Pat::Range { start, end } => {
+                let start_ty = self.infer_expr(*start, &Expectation::has_type(expected.clone()));
+                let end_ty = self.infer_expr(*end, &Expectation::has_type(start_ty));
+                end_ty
+            }
+            Pat::Lit(expr) => self.infer_expr(*expr, &Expectation::has_type(expected.clone())),
+            Pat::Missing => Ty::Unknown,
        };
        // use a new type variable if we got Ty::Unknown here
        let ty = self.insert_type_vars_shallow(ty);
diff --git a/crates/ra_hir_ty/src/tests/coercion.rs b/crates/ra_hir_ty/src/tests/coercion.rs
index 1e303f5ce..3e3d55c04 100644
--- a/crates/ra_hir_ty/src/tests/coercion.rs
+++ b/crates/ra_hir_ty/src/tests/coercion.rs
@@ -275,12 +275,14 @@ fn test(i: i32) {
    [70; 147) 'match ...     }': &[i32]
    [76; 77) 'i': i32
    [88; 89) '2': i32
+    [88; 89) '2': i32
    [93; 96) 'foo': fn foo<i32>(&[i32]) -> &[i32]
    [93; 102) 'foo(&[2])': &[i32]
    [97; 101) '&[2]': &[i32; _]
    [98; 101) '[2]': [i32; _]
    [99; 100) '2': i32
    [112; 113) '1': i32
+    [112; 113) '1': i32
    [117; 121) '&[1]': &[i32; _]
    [118; 121) '[1]': [i32; _]
    [119; 120) '1': i32
@@ -316,10 +318,12 @@ fn test(i: i32) {
    [70; 147) 'match ...     }': &[i32]
    [76; 77) 'i': i32
    [88; 89) '1': i32
+    [88; 89) '1': i32
    [93; 97) '&[1]': &[i32; _]
    [94; 97) '[1]': [i32; _]
    [95; 96) '1': i32
    [107; 108) '2': i32
+    [107; 108) '2': i32
    [112; 115) 'foo': fn foo<i32>(&[i32]) -> &[i32]
    [112; 121) 'foo(&[2])': &[i32]
    [116; 120) '&[2]': &[i32; _]
@@ -357,9 +361,11 @@ fn test() {
    [45; 142) 'match ...     }': *const i32
    [51; 52) '1': i32
    [63; 64) '1': i32
+    [63; 64) '1': i32
    [68; 69) 't': &mut i32
    [68; 81) 't as *mut i32': *mut i32
    [91; 92) '2': i32
+    [91; 92) '2': i32
    [96; 97) 't': &mut i32
    [96; 105) 't as &i32': &i32
    [115; 116) '_': i32
diff --git a/crates/ra_hir_ty/src/tests/patterns.rs b/crates/ra_hir_ty/src/tests/patterns.rs
index 76aa32024..6e5d2247c 100644
--- a/crates/ra_hir_ty/src/tests/patterns.rs
+++ b/crates/ra_hir_ty/src/tests/patterns.rs
@@ -82,6 +82,90 @@ fn test(x: &i32) {
 }
 #[test]
+fn infer_literal_pattern() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+fn any<T>() -> T { loop {} }
+fn test(x: &i32) {
+    if let "foo" = any() {}
+    if let 1 = any() {}
+    if let 1u32 = any() {}
+    if let 1f32 = any() {}
+    if let 1.0 = any() {}
+    if let true = any() {}
+}
+"#, true),
+        @r###"
+    [18; 29) '{ loop {} }': T
+    [20; 27) 'loop {}': !
+    [25; 27) '{}': ()
+    [38; 39) 'x': &i32
+    [47; 209) '{     ...) {} }': ()
+    [53; 76) 'if let...y() {}': ()
+    [60; 65) '"foo"': &str
+    [60; 65) '"foo"': &str
+    [68; 71) 'any': fn any<&str>() -> &str
+    [68; 73) 'any()': &str
+    [74; 76) '{}': ()
+    [81; 100) 'if let...y() {}': ()
+    [88; 89) '1': i32
+    [88; 89) '1': i32
+    [92; 95) 'any': fn any<i32>() -> i32
+    [92; 97) 'any()': i32
+    [98; 100) '{}': ()
+    [105; 127) 'if let...y() {}': ()
+    [112; 116) '1u32': u32
+    [112; 116) '1u32': u32
+    [119; 122) 'any': fn any<u32>() -> u32
+    [119; 124) 'any()': u32
+    [125; 127) '{}': ()
+    [132; 154) 'if let...y() {}': ()
+    [139; 143) '1f32': f32
+    [139; 143) '1f32': f32
+    [146; 149) 'any': fn any<f32>() -> f32
+    [146; 151) 'any()': f32
+    [152; 154) '{}': ()
+    [159; 180) 'if let...y() {}': ()
+    [166; 169) '1.0': f64
+    [166; 169) '1.0': f64
+    [172; 175) 'any': fn any<f64>() -> f64
+    [172; 177) 'any()': f64
+    [178; 180) '{}': ()
+    [185; 207) 'if let...y() {}': ()
+    [192; 196) 'true': bool
+    [192; 196) 'true': bool
+    [199; 202) 'any': fn any<bool>() -> bool
+    [199; 204) 'any()': bool
+    [205; 207) '{}': ()
+    "###
+    );
+}
+#[test]
+fn infer_range_pattern() {
+    assert_snapshot!(
+        infer_with_mismatches(r#"
+fn test(x: &i32) {
+    if let 1..76 = 2u32 {}
+    if let 1..=76 = 2u32 {}
+}
+"#, true),
+        @r###"
+    [9; 10) 'x': &i32
+    [18; 76) '{     ...2 {} }': ()
+    [24; 46) 'if let...u32 {}': ()
+    [31; 36) '1..76': u32
+    [39; 43) '2u32': u32
+    [44; 46) '{}': ()
+    [51; 74) 'if let...u32 {}': ()
+    [58; 64) '1..=76': u32
+    [67; 71) '2u32': u32
+    [72; 74) '{}': ()
+    "###
+    );
+}
+#[test]
 fn infer_pattern_match_ergonomics() {
    assert_snapshot!(
        infer(r#"
@@ -212,6 +296,7 @@ fn test() {
    [59; 62) 'arr': [f64; _]
    [73; 81) '[1.0, a]': [f64; _]
    [74; 77) '1.0': f64
+    [74; 77) '1.0': f64
    [79; 80) 'a': f64
    [85; 111) '{     ...     }': ()
    [99; 100) 'a': f64
diff --git a/crates/ra_hir_ty/src/tests/regression.rs b/crates/ra_hir_ty/src/tests/regression.rs
index a02e3ee05..2ee9b8f10 100644
--- a/crates/ra_hir_ty/src/tests/regression.rs
+++ b/crates/ra_hir_ty/src/tests/regression.rs
@@ -206,7 +206,8 @@ pub fn compute() {
    [24; 106) 'match ...     }': ()
    [30; 37) 'nope!()': {unknown}
    [48; 94) 'SizeSk...tail }': {unknown}
-    [82; 86) 'true': {unknown}
+    [82; 86) 'true': bool
+    [82; 86) 'true': bool
    [88; 92) 'tail': {unknown}
    [98; 100) '{}': ()
    "###
diff --git a/crates/ra_hir_ty/src/tests/simple.rs b/crates/ra_hir_ty/src/tests/simple.rs
index c140bd513..a600b947d 100644
--- a/crates/ra_hir_ty/src/tests/simple.rs
+++ b/crates/ra_hir_ty/src/tests/simple.rs
@@ -948,6 +948,7 @@ fn foo() {
    [165; 247) 'match ...     }': i32
    [171; 175) 'true': bool
    [186; 190) 'true': bool
+    [186; 190) 'true': bool
    [194; 195) '3': i32
    [205; 206) '_': bool
    [210; 241) '{     ...     }': !
@@ -956,6 +957,7 @@ fn foo() {
    [263; 320) 'match ...     }': i32
    [269; 273) 'true': bool
    [284; 288) 'true': bool
+    [284; 288) 'true': bool
    [292; 293) '4': i32
    [303; 304) '_': bool
    [308; 314) 'return': !
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index cd0757be5..93157bbba 100644
--- a/crates/ra_ide/src/completion.rs
+++ b/crates/ra_ide/src/completion.rs
@@ -5,8 +5,7 @@ mod completion_context;
 mod presentation;
 mod complete_dot;
-mod complete_record_literal;
+mod complete_record;
-mod complete_record_pattern;
 mod complete_pattern;
 mod complete_fn_param;
 mod complete_keyword;
@@ -34,15 +33,15 @@ pub use crate::completion::completion_item::{
 };
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct CompletionOptions {
+pub struct CompletionConfig {
    pub enable_postfix_completions: bool,
    pub add_call_parenthesis: bool,
    pub add_call_argument_snippets: bool,
 }
-impl Default for CompletionOptions {
+impl Default for CompletionConfig {
    fn default() -> Self {
-        CompletionOptions {
+        CompletionConfig {
            enable_postfix_completions: true,
            add_call_parenthesis: true,
            add_call_argument_snippets: true,
@@ -75,9 +74,9 @@ impl Default for CompletionOptions {
 pub(crate) fn completions(
    db: &RootDatabase,
    position: FilePosition,
-    options: &CompletionOptions,
+    config: &CompletionConfig,
 ) -> Option<Completions> {
-    let ctx = CompletionContext::new(db, position, options)?;
+    let ctx = CompletionContext::new(db, position, config)?;
    let mut acc = Completions::default();
@@ -89,8 +88,7 @@ pub(crate) fn completions(
    complete_path::complete_path(&mut acc, &ctx);
    complete_scope::complete_scope(&mut acc, &ctx);
    complete_dot::complete_dot(&mut acc, &ctx);
-    complete_record_literal::complete_record_literal(&mut acc, &ctx);
+    complete_record::complete_record(&mut acc, &ctx);
-    complete_record_pattern::complete_record_pattern(&mut acc, &ctx);
    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);
diff --git a/crates/ra_ide/src/completion/complete_postfix.rs b/crates/ra_ide/src/completion/complete_postfix.rs
index 0a00054b2..29c2881c6 100644
--- a/crates/ra_ide/src/completion/complete_postfix.rs
+++ b/crates/ra_ide/src/completion/complete_postfix.rs
@@ -15,7 +15,7 @@ use crate::{
 };
 pub(super) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
-    if !ctx.options.enable_postfix_completions {
+    if !ctx.config.enable_postfix_completions {
        return;
    }
diff --git a/crates/ra_ide/src/completion/complete_record.rs b/crates/ra_ide/src/completion/complete_record.rs
new file mode 100644
index 000000000..01dd8c6db
--- /dev/null
+++ b/crates/ra_ide/src/completion/complete_record.rs
@@ -0,0 +1,411 @@
+//! Complete fields in record literals and patterns.
+use crate::completion::{CompletionContext, Completions};
+use ra_syntax::{ast, ast::NameOwner, SmolStr};
+pub(super) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
+    let (ty, variant, already_present_fields) =
+        match (ctx.record_lit_pat.as_ref(), ctx.record_lit_syntax.as_ref()) {
+            (None, None) => return None,
+            (Some(_), Some(_)) => panic!("A record cannot be both a literal and a pattern"),
+            (Some(record_pat), _) => (
+                ctx.sema.type_of_pat(&record_pat.clone().into())?,
+                ctx.sema.resolve_record_pattern(record_pat)?,
+                pattern_ascribed_fields(record_pat),
+            ),
+            (_, Some(record_lit)) => (
+                ctx.sema.type_of_expr(&record_lit.clone().into())?,
+                ctx.sema.resolve_record_literal(record_lit)?,
+                literal_ascribed_fields(record_lit),
+            ),
+        };
+    for (field, field_ty) in ty.variant_fields(ctx.db, variant).into_iter().filter(|(field, _)| {
+        // FIXME: already_present_names better be `Vec<hir::Name>`
+        !already_present_fields.contains(&SmolStr::from(field.name(ctx.db).to_string()))
+    }) {
+        acc.add_field(ctx, field, &field_ty);
+    }
+    Some(())
+}
+fn literal_ascribed_fields(record_lit: &ast::RecordLit) -> Vec<SmolStr> {
+    record_lit
+        .record_field_list()
+        .map(|field_list| field_list.fields())
+        .map(|fields| {
+            fields
+                .into_iter()
+                .filter_map(|field| field.name_ref())
+                .map(|name_ref| name_ref.text().clone())
+                .collect()
+        })
+        .unwrap_or_default()
+}
+fn pattern_ascribed_fields(record_pat: &ast::RecordPat) -> Vec<SmolStr> {
+    record_pat
+        .record_field_pat_list()
+        .map(|pat_list| {
+            pat_list
+                .record_field_pats()
+                .filter_map(|fild_pat| fild_pat.name())
+                .chain(pat_list.bind_pats().filter_map(|bind_pat| bind_pat.name()))
+                .map(|name| name.text().clone())
+                .collect()
+        })
+        .unwrap_or_default()
+}
+#[cfg(test)]
+mod tests {
+    mod record_lit_tests {
+        use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+        use insta::assert_debug_snapshot;
+        fn complete(code: &str) -> Vec<CompletionItem> {
+            do_completion(code, CompletionKind::Reference)
+        }
+        #[test]
+        fn test_record_pattern_field() {
+            let completions = complete(
+                r"
+            struct S { foo: u32 }
+            fn process(f: S) {
+                match f {
+                    S { f<|>: 92 } => (),
+                }
+            }
+            ",
+            );
+            assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "foo",
+                source_range: [117; 118),
+                delete: [117; 118),
+                insert: "foo",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+        }
+        #[test]
+        fn test_record_pattern_enum_variant() {
+            let completions = complete(
+                r"
+            enum E {
+                S { foo: u32, bar: () }
+            }
+            fn process(e: E) {
+                match e {
+                    E::S { <|> } => (),
+                }
+            }
+            ",
+            );
+            assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "bar",
+                source_range: [161; 161),
+                delete: [161; 161),
+                insert: "bar",
+                kind: Field,
+                detail: "()",
+            },
+            CompletionItem {
+                label: "foo",
+                source_range: [161; 161),
+                delete: [161; 161),
+                insert: "foo",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+        }
+        #[test]
+        fn test_record_pattern_field_in_simple_macro() {
+            let completions = complete(
+                r"
+            macro_rules! m { ($e:expr) => { $e } }
+            struct S { foo: u32 }
+            fn process(f: S) {
+                m!(match f {
+                    S { f<|>: 92 } => (),
+                })
+            }
+            ",
+            );
+            assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "foo",
+                source_range: [171; 172),
+                delete: [171; 172),
+                insert: "foo",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+        }
+        #[test]
+        fn only_missing_fields_are_completed_in_destruct_pats() {
+            let completions = complete(
+                r"
+            struct S {
+                foo1: u32,
+                foo2: u32,
+                bar: u32,
+                baz: u32,
+            }
+            fn main() {
+                let s = S {
+                    foo1: 1,
+                    foo2: 2,
+                    bar: 3,
+                    baz: 4,
+                };
+                if let S { foo1, foo2: a, <|> } = s {}
+            }
+            ",
+            );
+            assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "bar",
+                source_range: [372; 372),
+                delete: [372; 372),
+                insert: "bar",
+                kind: Field,
+                detail: "u32",
+            },
+            CompletionItem {
+                label: "baz",
+                source_range: [372; 372),
+                delete: [372; 372),
+                insert: "baz",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+        }
+    }
+    mod record_pat_tests {
+        use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
+        use insta::assert_debug_snapshot;
+        fn complete(code: &str) -> Vec<CompletionItem> {
+            do_completion(code, CompletionKind::Reference)
+        }
+        #[test]
+        fn test_record_literal_deprecated_field() {
+            let completions = complete(
+                r"
+            struct A {
+                #[deprecated]
+                the_field: u32,
+            }
+            fn foo() {
+               A { the<|> }
+            }
+            ",
+            );
+            assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [142; 145),
+                delete: [142; 145),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+                deprecated: true,
+            },
+        ]
+        "###);
+        }
+        #[test]
+        fn test_record_literal_field() {
+            let completions = complete(
+                r"
+            struct A { the_field: u32 }
+            fn foo() {
+               A { the<|> }
+            }
+            ",
+            );
+            assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [83; 86),
+                delete: [83; 86),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+        }
+        #[test]
+        fn test_record_literal_enum_variant() {
+            let completions = complete(
+                r"
+            enum E {
+                A { a: u32 }
+            }
+            fn foo() {
+                let _ = E::A { <|> }
+            }
+            ",
+            );
+            assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "a",
+                source_range: [119; 119),
+                delete: [119; 119),
+                insert: "a",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+        }
+        #[test]
+        fn test_record_literal_two_structs() {
+            let completions = complete(
+                r"
+            struct A { a: u32 }
+            struct B { b: u32 }
+            fn foo() {
+               let _: A = B { <|> }
+            }
+            ",
+            );
+            assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "b",
+                source_range: [119; 119),
+                delete: [119; 119),
+                insert: "b",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+        }
+        #[test]
+        fn test_record_literal_generic_struct() {
+            let completions = complete(
+                r"
+            struct A<T> { a: T }
+            fn foo() {
+               let _: A<u32> = A { <|> }
+            }
+            ",
+            );
+            assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "a",
+                source_range: [93; 93),
+                delete: [93; 93),
+                insert: "a",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+        }
+        #[test]
+        fn test_record_literal_field_in_simple_macro() {
+            let completions = complete(
+                r"
+            macro_rules! m { ($e:expr) => { $e } }
+            struct A { the_field: u32 }
+            fn foo() {
+               m!(A { the<|> })
+            }
+            ",
+            );
+            assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "the_field",
+                source_range: [137; 140),
+                delete: [137; 140),
+                insert: "the_field",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+        }
+        #[test]
+        fn only_missing_fields_are_completed() {
+            let completions = complete(
+                r"
+            struct S {
+                foo1: u32,
+                foo2: u32,
+                bar: u32,
+                baz: u32,
+            }
+            fn main() {
+                let foo1 = 1;
+                let s = S {
+                    foo1,
+                    foo2: 5,
+                    <|>
+                }
+            }
+            ",
+            );
+            assert_debug_snapshot!(completions, @r###"
+        [
+            CompletionItem {
+                label: "bar",
+                source_range: [302; 302),
+                delete: [302; 302),
+                insert: "bar",
+                kind: Field,
+                detail: "u32",
+            },
+            CompletionItem {
+                label: "baz",
+                source_range: [302; 302),
+                delete: [302; 302),
+                insert: "baz",
+                kind: Field,
+                detail: "u32",
+            },
+        ]
+        "###);
+        }
+    }
+}
diff --git a/crates/ra_ide/src/completion/complete_record_literal.rs b/crates/ra_ide/src/completion/complete_record_literal.rs
deleted file mode 100644
index e4e764f58..000000000
--- a/crates/ra_ide/src/completion/complete_record_literal.rs
+++ /dev/null
@@ -1,241 +0,0 @@
-//! FIXME: write short doc here
-use crate::completion::{CompletionContext, Completions};
-use ra_syntax::SmolStr;
-/// Complete fields in fields literals.
-pub(super) fn complete_record_literal(acc: &mut Completions, ctx: &CompletionContext) {
-    let (ty, variant) = match ctx.record_lit_syntax.as_ref().and_then(|it| {
-        Some((ctx.sema.type_of_expr(&it.clone().into())?, ctx.sema.resolve_record_literal(it)?))
-    }) {
-        Some(it) => it,
-        _ => return,
-    };
-    let already_present_names: Vec<SmolStr> = ctx
-        .record_lit_syntax
-        .as_ref()
-        .and_then(|record_literal| record_literal.record_field_list())
-        .map(|field_list| field_list.fields())
-        .map(|fields| {
-            fields
-                .into_iter()
-                .filter_map(|field| field.name_ref())
-                .map(|name_ref| name_ref.text().clone())
-                .collect()
-        })
-        .unwrap_or_default();
-    for (field, field_ty) in ty.variant_fields(ctx.db, variant) {
-        if !already_present_names.contains(&SmolStr::from(field.name(ctx.db).to_string())) {
-            acc.add_field(ctx, field, &field_ty);
-        }
-    }
-}
-#[cfg(test)]
-mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
-    fn complete(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Reference)
-    }
-    #[test]
-    fn test_record_literal_deprecated_field() {
-        let completions = complete(
-            r"
-            struct A {
-                #[deprecated]
-                the_field: u32,
-            }
-            fn foo() {
-               A { the<|> }
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: [142; 145),
-                delete: [142; 145),
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-                deprecated: true,
-            },
-        ]
-        "###);
-    }
-    #[test]
-    fn test_record_literal_field() {
-        let completions = complete(
-            r"
-            struct A { the_field: u32 }
-            fn foo() {
-               A { the<|> }
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: [83; 86),
-                delete: [83; 86),
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-    }
-    #[test]
-    fn test_record_literal_enum_variant() {
-        let completions = complete(
-            r"
-            enum E {
-                A { a: u32 }
-            }
-            fn foo() {
-                let _ = E::A { <|> }
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "a",
-                source_range: [119; 119),
-                delete: [119; 119),
-                insert: "a",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-    }
-    #[test]
-    fn test_record_literal_two_structs() {
-        let completions = complete(
-            r"
-            struct A { a: u32 }
-            struct B { b: u32 }
-            fn foo() {
-               let _: A = B { <|> }
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "b",
-                source_range: [119; 119),
-                delete: [119; 119),
-                insert: "b",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-    }
-    #[test]
-    fn test_record_literal_generic_struct() {
-        let completions = complete(
-            r"
-            struct A<T> { a: T }
-            fn foo() {
-               let _: A<u32> = A { <|> }
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "a",
-                source_range: [93; 93),
-                delete: [93; 93),
-                insert: "a",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-    }
-    #[test]
-    fn test_record_literal_field_in_simple_macro() {
-        let completions = complete(
-            r"
-            macro_rules! m { ($e:expr) => { $e } }
-            struct A { the_field: u32 }
-            fn foo() {
-               m!(A { the<|> })
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "the_field",
-                source_range: [137; 140),
-                delete: [137; 140),
-                insert: "the_field",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-    }
-    #[test]
-    fn only_missing_fields_are_completed() {
-        let completions = complete(
-            r"
-            struct S {
-                foo1: u32,
-                foo2: u32,
-                bar: u32,
-                baz: u32,
-            }
-            fn main() {
-                let foo1 = 1;
-                let s = S {
-                    foo1,
-                    foo2: 5,
-                    <|>
-                }
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "bar",
-                source_range: [302; 302),
-                delete: [302; 302),
-                insert: "bar",
-                kind: Field,
-                detail: "u32",
-            },
-            CompletionItem {
-                label: "baz",
-                source_range: [302; 302),
-                delete: [302; 302),
-                insert: "baz",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-    }
-}
diff --git a/crates/ra_ide/src/completion/complete_record_pattern.rs b/crates/ra_ide/src/completion/complete_record_pattern.rs
deleted file mode 100644
index 962376428..000000000
--- a/crates/ra_ide/src/completion/complete_record_pattern.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-//! FIXME: write short doc here
-use crate::completion::{CompletionContext, Completions};
-pub(super) fn complete_record_pattern(acc: &mut Completions, ctx: &CompletionContext) {
-    let (ty, variant) = match ctx.record_lit_pat.as_ref().and_then(|it| {
-        Some((ctx.sema.type_of_pat(&it.clone().into())?, ctx.sema.resolve_record_pattern(it)?))
-    }) {
-        Some(it) => it,
-        _ => return,
-    };
-    for (field, field_ty) in ty.variant_fields(ctx.db, variant) {
-        acc.add_field(ctx, field, &field_ty);
-    }
-}
-#[cfg(test)]
-mod tests {
-    use crate::completion::{test_utils::do_completion, CompletionItem, CompletionKind};
-    use insta::assert_debug_snapshot;
-    fn complete(code: &str) -> Vec<CompletionItem> {
-        do_completion(code, CompletionKind::Reference)
-    }
-    #[test]
-    fn test_record_pattern_field() {
-        let completions = complete(
-            r"
-            struct S { foo: u32 }
-            fn process(f: S) {
-                match f {
-                    S { f<|>: 92 } => (),
-                }
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "foo",
-                source_range: [117; 118),
-                delete: [117; 118),
-                insert: "foo",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-    }
-    #[test]
-    fn test_record_pattern_enum_variant() {
-        let completions = complete(
-            r"
-            enum E {
-                S { foo: u32, bar: () }
-            }
-            fn process(e: E) {
-                match e {
-                    E::S { <|> } => (),
-                }
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "bar",
-                source_range: [161; 161),
-                delete: [161; 161),
-                insert: "bar",
-                kind: Field,
-                detail: "()",
-            },
-            CompletionItem {
-                label: "foo",
-                source_range: [161; 161),
-                delete: [161; 161),
-                insert: "foo",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-    }
-    #[test]
-    fn test_record_pattern_field_in_simple_macro() {
-        let completions = complete(
-            r"
-            macro_rules! m { ($e:expr) => { $e } }
-            struct S { foo: u32 }
-            fn process(f: S) {
-                m!(match f {
-                    S { f<|>: 92 } => (),
-                })
-            }
-            ",
-        );
-        assert_debug_snapshot!(completions, @r###"
-        [
-            CompletionItem {
-                label: "foo",
-                source_range: [171; 172),
-                delete: [171; 172),
-                insert: "foo",
-                kind: Field,
-                detail: "u32",
-            },
-        ]
-        "###);
-    }
-}
diff --git a/crates/ra_ide/src/completion/completion_context.rs b/crates/ra_ide/src/completion/completion_context.rs
index 319e33b61..fdc0da2c5 100644
--- a/crates/ra_ide/src/completion/completion_context.rs
+++ b/crates/ra_ide/src/completion/completion_context.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
 };
 use ra_text_edit::AtomTextEdit;
-use crate::{completion::CompletionOptions, FilePosition};
+use crate::{completion::CompletionConfig, FilePosition};
 /// `CompletionContext` is created early during completion to figure out, where
 /// exactly is the cursor, syntax-wise.
@@ -19,7 +19,7 @@ use crate::{completion::CompletionOptions, FilePosition};
 pub(crate) struct CompletionContext<'a> {
    pub(super) sema: Semantics<'a, RootDatabase>,
    pub(super) db: &'a RootDatabase,
-    pub(super) options: &'a CompletionOptions,
+    pub(super) config: &'a CompletionConfig,
    pub(super) offset: TextUnit,
    /// The token before the cursor, in the original file.
    pub(super) original_token: SyntaxToken,
@@ -61,7 +61,7 @@ impl<'a> CompletionContext<'a> {
    pub(super) fn new(
        db: &'a RootDatabase,
        position: FilePosition,
-        options: &'a CompletionOptions,
+        config: &'a CompletionConfig,
    ) -> Option<CompletionContext<'a>> {
        let sema = Semantics::new(db);
@@ -85,7 +85,7 @@ impl<'a> CompletionContext<'a> {
        let mut ctx = CompletionContext {
            sema,
            db,
-            options,
+            config,
            original_token,
            token,
            offset: position.offset,
diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs
index 60f1b83f3..1c7c0924d 100644
--- a/crates/ra_ide/src/completion/presentation.rs
+++ b/crates/ra_ide/src/completion/presentation.rs
@@ -106,7 +106,7 @@ impl Completions {
        };
        // Add `<>` for generic types
-        if ctx.is_path_type && !ctx.has_type_args && ctx.options.add_call_parenthesis {
+        if ctx.is_path_type && !ctx.has_type_args && ctx.config.add_call_parenthesis {
            let has_non_default_type_params = match resolution {
                ScopeDef::ModuleDef(Adt(it)) => it.has_non_default_type_params(ctx.db),
                ScopeDef::ModuleDef(TypeAlias(it)) => it.has_non_default_type_params(ctx.db),
@@ -211,14 +211,14 @@ impl Completions {
                .detail(function_signature.to_string());
        // If not an import, add parenthesis automatically.
-        if ctx.use_item_syntax.is_none() && !ctx.is_call && ctx.options.add_call_parenthesis {
+        if ctx.use_item_syntax.is_none() && !ctx.is_call && ctx.config.add_call_parenthesis {
            tested_by!(inserts_parens_for_function_calls);
            let (snippet, label) = if params.is_empty() || has_self_param && params.len() == 1 {
                (format!("{}()$0", name), format!("{}()", name))
            } else {
                builder = builder.trigger_call_info();
-                let snippet = if ctx.options.add_call_argument_snippets {
+                let snippet = if ctx.config.add_call_argument_snippets {
                    let to_skip = if has_self_param { 1 } else { 0 };
                    let function_params_snippet = function_signature
                        .parameter_names
@@ -311,7 +311,7 @@ mod tests {
    use crate::completion::{
        test_utils::{do_completion, do_completion_with_options},
-        CompletionItem, CompletionKind, CompletionOptions,
+        CompletionConfig, CompletionItem, CompletionKind,
    };
    fn do_reference_completion(ra_fixture: &str) -> Vec<CompletionItem> {
@@ -320,7 +320,7 @@ mod tests {
    fn do_reference_completion_with_options(
        ra_fixture: &str,
-        options: CompletionOptions,
+        options: CompletionConfig,
    ) -> Vec<CompletionItem> {
        do_completion_with_options(ra_fixture, CompletionKind::Reference, &options)
    }
@@ -589,7 +589,7 @@ mod tests {
                    s.f<|>
                }
                ",
-                CompletionOptions {
+                CompletionConfig {
                    add_call_argument_snippets: false,
                    .. Default::default()
                }
diff --git a/crates/ra_ide/src/completion/test_utils.rs b/crates/ra_ide/src/completion/test_utils.rs
index 136857315..eb90b5279 100644
--- a/crates/ra_ide/src/completion/test_utils.rs
+++ b/crates/ra_ide/src/completion/test_utils.rs
@@ -1,19 +1,19 @@
 //! Runs completion for testing purposes.
 use crate::{
-    completion::{completion_item::CompletionKind, CompletionOptions},
+    completion::{completion_item::CompletionKind, CompletionConfig},
    mock_analysis::{analysis_and_position, single_file_with_position},
    CompletionItem,
 };
 pub(crate) fn do_completion(code: &str, kind: CompletionKind) -> Vec<CompletionItem> {
-    do_completion_with_options(code, kind, &CompletionOptions::default())
+    do_completion_with_options(code, kind, &CompletionConfig::default())
 }
 pub(crate) fn do_completion_with_options(
    code: &str,
    kind: CompletionKind,
-    options: &CompletionOptions,
+    options: &CompletionConfig,
 ) -> Vec<CompletionItem> {
    let (analysis, position) = if code.contains("//-") {
        analysis_and_position(code)
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index f4f0751c0..4b133b19b 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -11,14 +11,14 @@ use ra_syntax::{
 use crate::{FileId, FunctionSignature};
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct InlayHintsOptions {
+pub struct InlayHintsConfig {
    pub type_hints: bool,
    pub parameter_hints: bool,
    pub chaining_hints: bool,
    pub max_length: Option<usize>,
 }
-impl Default for InlayHintsOptions {
+impl Default for InlayHintsConfig {
    fn default() -> Self {
        Self { type_hints: true, parameter_hints: true, chaining_hints: true, max_length: None }
    }
@@ -41,7 +41,7 @@ pub struct InlayHint {
 pub(crate) fn inlay_hints(
    db: &RootDatabase,
    file_id: FileId,
-    options: &InlayHintsOptions,
+    config: &InlayHintsConfig,
 ) -> Vec<InlayHint> {
    let _p = profile("inlay_hints");
    let sema = Semantics::new(db);
@@ -50,14 +50,14 @@ pub(crate) fn inlay_hints(
    let mut res = Vec::new();
    for node in file.syntax().descendants() {
        if let Some(expr) = ast::Expr::cast(node.clone()) {
-            get_chaining_hints(&mut res, &sema, options, expr);
+            get_chaining_hints(&mut res, &sema, config, expr);
        }
        match_ast! {
            match node {
-                ast::CallExpr(it) => { get_param_name_hints(&mut res, &sema, options, ast::Expr::from(it)); },
+                ast::CallExpr(it) => { get_param_name_hints(&mut res, &sema, config, ast::Expr::from(it)); },
-                ast::MethodCallExpr(it) => { get_param_name_hints(&mut res, &sema, options, ast::Expr::from(it)); },
+                ast::MethodCallExpr(it) => { get_param_name_hints(&mut res, &sema, config, ast::Expr::from(it)); },
-                ast::BindPat(it) => { get_bind_pat_hints(&mut res, &sema, options, it); },
+                ast::BindPat(it) => { get_bind_pat_hints(&mut res, &sema, config, it); },
                _ => (),
            }
        }
@@ -68,15 +68,14 @@ pub(crate) fn inlay_hints(
 fn get_chaining_hints(
    acc: &mut Vec<InlayHint>,
    sema: &Semantics<RootDatabase>,
-    options: &InlayHintsOptions,
+    config: &InlayHintsConfig,
    expr: ast::Expr,
 ) -> Option<()> {
-    if !options.chaining_hints {
+    if !config.chaining_hints {
        return None;
    }
-    let ty = sema.type_of_expr(&expr)?;
+    if matches!(expr, ast::Expr::RecordLit(_)) {
-    if ty.is_unknown() {
        return None;
    }
@@ -95,7 +94,18 @@ fn get_chaining_hints(
    let next = tokens.next()?.kind();
    let next_next = tokens.next()?.kind();
    if next == SyntaxKind::WHITESPACE && next_next == SyntaxKind::DOT {
-        let label = ty.display_truncated(sema.db, options.max_length).to_string();
+        let ty = sema.type_of_expr(&expr)?;
+        if ty.is_unknown() {
+            return None;
+        }
+        if matches!(expr, ast::Expr::PathExpr(_)) {
+            if let Some(Adt::Struct(st)) = ty.as_adt() {
+                if st.fields(sema.db).is_empty() {
+                    return None;
+                }
+            }
+        }
+        let label = ty.display_truncated(sema.db, config.max_length).to_string();
        acc.push(InlayHint {
            range: expr.syntax().text_range(),
            kind: InlayKind::ChainingHint,
@@ -108,10 +118,10 @@ fn get_chaining_hints(
 fn get_param_name_hints(
    acc: &mut Vec<InlayHint>,
    sema: &Semantics<RootDatabase>,
-    options: &InlayHintsOptions,
+    config: &InlayHintsConfig,
    expr: ast::Expr,
 ) -> Option<()> {
-    if !options.parameter_hints {
+    if !config.parameter_hints {
        return None;
    }
@@ -148,10 +158,10 @@ fn get_param_name_hints(
 fn get_bind_pat_hints(
    acc: &mut Vec<InlayHint>,
    sema: &Semantics<RootDatabase>,
-    options: &InlayHintsOptions,
+    config: &InlayHintsConfig,
    pat: ast::BindPat,
 ) -> Option<()> {
-    if !options.type_hints {
+    if !config.type_hints {
        return None;
    }
@@ -164,7 +174,7 @@ fn get_bind_pat_hints(
    acc.push(InlayHint {
        range: pat.syntax().text_range(),
        kind: InlayKind::TypeHint,
-        label: ty.display_truncated(sema.db, options.max_length).to_string().into(),
+        label: ty.display_truncated(sema.db, config.max_length).to_string().into(),
    });
    Some(())
 }
@@ -270,7 +280,7 @@ fn get_fn_signature(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<
 #[cfg(test)]
 mod tests {
-    use crate::inlay_hints::InlayHintsOptions;
+    use crate::inlay_hints::InlayHintsConfig;
    use insta::assert_debug_snapshot;
    use crate::mock_analysis::single_file;
@@ -284,7 +294,7 @@ mod tests {
                let _x = foo(4, 4);
            }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: true, type_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: true, type_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
        [
            InlayHint {
                range: [106; 107),
@@ -308,7 +318,7 @@ mod tests {
                let _x = foo(4, 4);
            }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ type_hints: false, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"[]"###);
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ type_hints: false, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"[]"###);
    }
    #[test]
@@ -320,7 +330,7 @@ mod tests {
                let _x = foo(4, 4);
            }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ type_hints: true, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ type_hints: true, parameter_hints: false, chaining_hints: false, max_length: None}).unwrap(), @r###"
        [
            InlayHint {
                range: [97; 99),
@@ -344,7 +354,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [69; 71),
@@ -401,7 +411,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [193; 197),
@@ -481,7 +491,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [21; 30),
@@ -545,7 +555,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [21; 30),
@@ -595,7 +605,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [188; 192),
@@ -690,7 +700,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [188; 192),
@@ -785,7 +795,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [252; 256),
@@ -857,7 +867,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
        [
            InlayHint {
                range: [74; 75),
@@ -945,7 +955,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions::default()).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig::default()).unwrap(), @r###"
        [
            InlayHint {
                range: [798; 809),
@@ -1067,7 +1077,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
        []
        "###
        );
@@ -1093,7 +1103,7 @@ fn main() {
 }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig { max_length: Some(8), ..Default::default() }).unwrap(), @r###"
        []
        "###
        );
@@ -1115,7 +1125,7 @@ fn main() {
                    .into_c();
            }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
        [
            InlayHint {
                range: [232; 269),
@@ -1144,7 +1154,7 @@ fn main() {
                let c = A(B(C)).into_b().into_c();
            }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"[]"###);
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"[]"###);
    }
    #[test]
@@ -1154,32 +1164,35 @@ fn main() {
            struct A { pub b: B }
            struct B { pub c: C }
            struct C(pub bool);
+            struct D;
+            impl D {
+                fn foo(&self) -> i32 { 42 }
+            }
            fn main() {
                let x = A { b: B { c: C(true) } }
                    .b
                    .c
                    .0;
+                let x = D
+                    .foo();
            }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
        [
            InlayHint {
-                range: [150; 221),
+                range: [252; 323),
                kind: ChainingHint,
                label: "C",
            },
            InlayHint {
-                range: [150; 198),
+                range: [252; 300),
                kind: ChainingHint,
                label: "B",
            },
-            InlayHint {
+        ]
-                range: [150; 175),
+        "###);
-                kind: ChainingHint,
-                label: "A",
-            },
-        ]"###);
    }
    #[test]
@@ -1204,7 +1217,7 @@ fn main() {
                    .into_c();
            }"#,
        );
-        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsOptions{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
+        assert_debug_snapshot!(analysis.inlay_hints(file_id, &InlayHintsConfig{ parameter_hints: false, type_hints: false, chaining_hints: true, max_length: None}).unwrap(), @r###"
        [
            InlayHint {
                range: [403; 452),
diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index e43414985..285381086 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -62,13 +62,13 @@ use crate::display::ToNav;
 pub use crate::{
    assists::{Assist, AssistId},
    call_hierarchy::CallItem,
-    completion::{CompletionItem, CompletionItemKind, CompletionOptions, InsertTextFormat},
+    completion::{CompletionConfig, CompletionItem, CompletionItemKind, InsertTextFormat},
    diagnostics::Severity,
    display::{file_structure, FunctionSignature, NavigationTarget, StructureNode},
    expand_macro::ExpandedMacro,
    folding_ranges::{Fold, FoldKind},
    hover::HoverResult,
-    inlay_hints::{InlayHint, InlayHintsOptions, InlayKind},
+    inlay_hints::{InlayHint, InlayHintsConfig, InlayKind},
    references::{Declaration, Reference, ReferenceAccess, ReferenceKind, ReferenceSearchResult},
    runnables::{Runnable, RunnableKind, TestId},
    source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
@@ -138,6 +138,11 @@ impl AnalysisHost {
    pub fn new(lru_capacity: Option<usize>) -> AnalysisHost {
        AnalysisHost { db: RootDatabase::new(lru_capacity) }
    }
+    pub fn update_lru_capacity(&mut self, lru_capacity: Option<usize>) {
+        self.db.update_lru_capacity(lru_capacity);
+    }
    /// Returns a snapshot of the current state, which you can query for
    /// semantic information.
    pub fn analysis(&self) -> Analysis {
@@ -320,9 +325,9 @@ impl Analysis {
    pub fn inlay_hints(
        &self,
        file_id: FileId,
-        inlay_hint_opts: &InlayHintsOptions,
+        config: &InlayHintsConfig,
    ) -> Cancelable<Vec<InlayHint>> {
-        self.with_db(|db| inlay_hints::inlay_hints(db, file_id, inlay_hint_opts))
+        self.with_db(|db| inlay_hints::inlay_hints(db, file_id, config))
    }
    /// Returns the set of folding ranges.
@@ -445,9 +450,9 @@ impl Analysis {
    pub fn completions(
        &self,
        position: FilePosition,
-        options: &CompletionOptions,
+        config: &CompletionConfig,
    ) -> Cancelable<Option<Vec<CompletionItem>>> {
-        self.with_db(|db| completion::completions(db, position, options).map(Into::into))
+        self.with_db(|db| completion::completions(db, position, config).map(Into::into))
    }
    /// Computes assists (aka code actions aka intentions) for the given
diff --git a/crates/ra_ide/src/ssr.rs b/crates/ra_ide/src/ssr.rs
index 1c9710a5d..1abb891c1 100644
--- a/crates/ra_ide/src/ssr.rs
+++ b/crates/ra_ide/src/ssr.rs
@@ -5,7 +5,7 @@ use ra_db::{SourceDatabase, SourceDatabaseExt};
 use ra_ide_db::symbol_index::SymbolsDatabase;
 use ra_ide_db::RootDatabase;
 use ra_syntax::ast::make::try_expr_from_text;
-use ra_syntax::ast::{AstToken, Comment};
+use ra_syntax::ast::{AstToken, Comment, RecordField, RecordLit};
 use ra_syntax::{AstNode, SyntaxElement, SyntaxNode};
 use ra_text_edit::{TextEdit, TextEditBuilder};
 use rustc_hash::FxHashMap;
@@ -186,47 +186,102 @@ fn create_name<'a>(name: &str, vars: &'a mut Vec<Var>) -> Result<&'a str, SsrErr
 }
 fn find(pattern: &SsrPattern, code: &SyntaxNode) -> SsrMatches {
+    fn check_record_lit(
+        pattern: RecordLit,
+        code: RecordLit,
+        placeholders: &[Var],
+        match_: Match,
+    ) -> Option<Match> {
+        let match_ = check_opt_nodes(pattern.path(), code.path(), placeholders, match_)?;
+        let mut pattern_fields =
+            pattern.record_field_list().map(|x| x.fields().collect()).unwrap_or(vec![]);
+        let mut code_fields =
+            code.record_field_list().map(|x| x.fields().collect()).unwrap_or(vec![]);
+        if pattern_fields.len() != code_fields.len() {
+            return None;
+        }
+        let by_name = |a: &RecordField, b: &RecordField| {
+            a.name_ref()
+                .map(|x| x.syntax().text().to_string())
+                .cmp(&b.name_ref().map(|x| x.syntax().text().to_string()))
+        };
+        pattern_fields.sort_by(by_name);
+        code_fields.sort_by(by_name);
+        pattern_fields.into_iter().zip(code_fields.into_iter()).fold(
+            Some(match_),
+            |accum, (a, b)| {
+                accum.and_then(|match_| check_opt_nodes(Some(a), Some(b), placeholders, match_))
+            },
+        )
+    }
+    fn check_opt_nodes(
+        pattern: Option<impl AstNode>,
+        code: Option<impl AstNode>,
+        placeholders: &[Var],
+        match_: Match,
+    ) -> Option<Match> {
+        match (pattern, code) {
+            (Some(pattern), Some(code)) => check(
+                &SyntaxElement::from(pattern.syntax().clone()),
+                &SyntaxElement::from(code.syntax().clone()),
+                placeholders,
+                match_,
+            ),
+            (None, None) => Some(match_),
+            _ => None,
+        }
+    }
    fn check(
        pattern: &SyntaxElement,
        code: &SyntaxElement,
        placeholders: &[Var],
        mut match_: Match,
    ) -> Option<Match> {
-        match (pattern, code) {
+        match (&pattern, &code) {
-            (SyntaxElement::Token(ref pattern), SyntaxElement::Token(ref code)) => {
+            (SyntaxElement::Token(pattern), SyntaxElement::Token(code)) => {
                if pattern.text() == code.text() {
                    Some(match_)
                } else {
                    None
                }
            }
-            (SyntaxElement::Node(ref pattern), SyntaxElement::Node(ref code)) => {
+            (SyntaxElement::Node(pattern), SyntaxElement::Node(code)) => {
                if placeholders.iter().any(|n| n.0.as_str() == pattern.text()) {
                    match_.binding.insert(Var(pattern.text().to_string()), code.clone());
                    Some(match_)
                } else {
-                    let mut pattern_children = pattern
+                    if let (Some(pattern), Some(code)) =
-                        .children_with_tokens()
+                        (RecordLit::cast(pattern.clone()), RecordLit::cast(code.clone()))
-                        .filter(|element| !element.kind().is_trivia());
+                    {
-                    let mut code_children =
+                        check_record_lit(pattern, code, placeholders, match_)
-                        code.children_with_tokens().filter(|element| !element.kind().is_trivia());
+                    } else {
-                    let new_ignored_comments = code.children_with_tokens().filter_map(|element| {
+                        let mut pattern_children = pattern
-                        element.as_token().and_then(|token| Comment::cast(token.clone()))
+                            .children_with_tokens()
-                    });
+                            .filter(|element| !element.kind().is_trivia());
-                    match_.ignored_comments.extend(new_ignored_comments);
+                        let mut code_children = code
-                    let match_from_children = pattern_children
+                            .children_with_tokens()
-                        .by_ref()
+                            .filter(|element| !element.kind().is_trivia());
-                        .zip(code_children.by_ref())
+                        let new_ignored_comments =
-                        .fold(Some(match_), |accum, (a, b)| {
+                            code.children_with_tokens().filter_map(|element| {
-                            accum.and_then(|match_| check(&a, &b, placeholders, match_))
+                                element.as_token().and_then(|token| Comment::cast(token.clone()))
-                        });
+                            });
-                    match_from_children.and_then(|match_| {
+                        match_.ignored_comments.extend(new_ignored_comments);
-                        if pattern_children.count() == 0 && code_children.count() == 0 {
+                        pattern_children
-                            Some(match_)
+                            .by_ref()
-                        } else {
+                            .zip(code_children.by_ref())
-                            None
+                            .fold(Some(match_), |accum, (a, b)| {
-                        }
+                                accum.and_then(|match_| check(&a, &b, placeholders, match_))
-                    })
+                            })
+                            .filter(|_| {
+                                pattern_children.next().is_none() && code_children.next().is_none()
+                            })
+                    }
                }
            }
            _ => None,
@@ -434,4 +489,13 @@ mod tests {
            "fn main() { bar(5)/* using 5 */ }",
        )
    }
+    #[test]
+    fn ssr_struct_lit() {
+        assert_ssr_transform(
+            "foo{a: $a:expr, b: $b:expr} ==>> foo::new($a, $b)",
+            "fn main() { foo{b:2, a:1} }",
+            "fn main() { foo::new(1, 2) }",
+        )
+    }
 }
diff --git a/crates/ra_ide_db/src/lib.rs b/crates/ra_ide_db/src/lib.rs
index 4faeefa8d..e6f2d36e9 100644
--- a/crates/ra_ide_db/src/lib.rs
+++ b/crates/ra_ide_db/src/lib.rs
@@ -115,12 +115,16 @@ impl RootDatabase {
        db.set_crate_graph_with_durability(Default::default(), Durability::HIGH);
        db.set_local_roots_with_durability(Default::default(), Durability::HIGH);
        db.set_library_roots_with_durability(Default::default(), Durability::HIGH);
-        let lru_capacity = lru_capacity.unwrap_or(ra_db::DEFAULT_LRU_CAP);
+        db.update_lru_capacity(lru_capacity);
-        db.query_mut(ra_db::ParseQuery).set_lru_capacity(lru_capacity);
-        db.query_mut(hir::db::ParseMacroQuery).set_lru_capacity(lru_capacity);
-        db.query_mut(hir::db::MacroExpandQuery).set_lru_capacity(lru_capacity);
        db
    }
+    pub fn update_lru_capacity(&mut self, lru_capacity: Option<usize>) {
+        let lru_capacity = lru_capacity.unwrap_or(ra_db::DEFAULT_LRU_CAP);
+        self.query_mut(ra_db::ParseQuery).set_lru_capacity(lru_capacity);