8 files changed, 560 insertions, 465 deletions

diff --git a/crates/ra_flycheck/src/lib.rs b/crates/ra_flycheck/src/lib.rs
index 75aece45f..13494a731 100644
--- a/crates/ra_flycheck/src/lib.rs
+++ b/crates/ra_flycheck/src/lib.rs
@@ -4,9 +4,9 @@
 mod conv;
 
 use std::{
-    error, fmt,
-    io::{BufRead, BufReader},
-    path::{Path, PathBuf},
+    env,
+    io::{self, BufRead, BufReader},
+    path::PathBuf,
     process::{Command, Stdio},
     time::Instant,
 };
@@ -23,10 +23,9 @@ use crate::conv::{map_rust_diagnostic_to_lsp, MappedRustDiagnostic};
 pub use crate::conv::url_from_path_with_drive_lowercasing;
 
 #[derive(Clone, Debug)]
-pub struct CheckConfig {
-    pub args: Vec<String>,
-    pub command: String,
-    pub all_targets: bool,
+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
@@ -42,12 +41,11 @@ pub struct Flycheck {
 }
 
 impl Flycheck {
-    pub fn new(config: CheckConfig, workspace_root: PathBuf) -> 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 || {
-            let mut check = FlycheckThread::new(config, workspace_root);
-            check.run(&task_send, &cmd_recv);
+            FlycheckThread::new(config, workspace_root).run(&task_send, &cmd_recv);
         });
         Flycheck { task_recv, cmd_send, handle }
     }
@@ -76,7 +74,7 @@ pub enum CheckCommand {
 }
 
 struct FlycheckThread {
-    options: CheckConfig,
+    config: FlycheckConfig,
     workspace_root: PathBuf,
     last_update_req: Option<Instant>,
     // XXX: drop order is significant
@@ -90,9 +88,9 @@ struct FlycheckThread {
 }
 
 impl FlycheckThread {
-    fn new(options: CheckConfig, workspace_root: PathBuf) -> FlycheckThread {
+    fn new(config: FlycheckConfig, workspace_root: PathBuf) -> FlycheckThread {
         FlycheckThread {
-            options,
+            config,
             workspace_root,
             last_update_req: None,
             message_recv: never(),
@@ -216,27 +214,34 @@ impl FlycheckThread {
         self.message_recv = never();
         self.check_process = None;
 
-        let mut args: Vec<String> = vec![
-            self.options.command.clone(),
-            "--workspace".to_string(),
-            "--message-format=json".to_string(),
-            "--manifest-path".to_string(),
-            format!("{}/Cargo.toml", self.workspace_root.display()),
-        ];
-        if self.options.all_targets {
-            args.push("--all-targets".to_string());
-        }
-        args.extend(self.options.args.iter().cloned());
+        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();
-        let workspace_root = self.workspace_root.to_owned();
         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(&args, Some(&workspace_root), &mut |message| {
+            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,
@@ -274,33 +279,12 @@ enum CheckEvent {
     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 {}
-
 fn run_cargo(
-    args: &[String],
-    current_dir: Option<&Path>,
+    mut command: Command,
     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");
+) -> 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
@@ -314,13 +298,7 @@ fn run_cargo(
     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 line = line?;
 
         let message = serde_json::from_str::<cargo_metadata::Message>(&line);
         let message = match message {
@@ -341,19 +319,22 @@ fn run_cargo(
     // 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
+    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: {:?}): cargo {}",
-                exit_code,
-                args.join(" ")
-            )
-        }
-        Err(err) => format!("io error: {:?}", err),
-        Ok(_) => return Ok(()),
-    };
+                "the command produced no valid metadata (exit code: {:?}): {:?}",
+                exit_status, command
+            ),
+        ));
+    }
+
+    Ok(())
+}
 
-    Err(CargoError(err_msg))
+fn cargo_binary() -> String {
+    env::var("CARGO").unwrap_or_else(|_| "cargo".to_string())
 }
diff --git a/crates/ra_ide/src/completion.rs b/crates/ra_ide/src/completion.rs
index b683572fb..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_pattern;
+mod complete_record;
 mod complete_pattern;
 mod complete_fn_param;
 mod complete_keyword;
@@ -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_pattern::complete_record_pattern(&mut acc, &ctx);
+    complete_record::complete_record(&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_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/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) {
-            (SyntaxElement::Token(ref pattern), SyntaxElement::Token(ref code)) => {
+        match (&pattern, &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
-                        .children_with_tokens()
-                        .filter(|element| !element.kind().is_trivia());
-                    let mut code_children =
-                        code.children_with_tokens().filter(|element| !element.kind().is_trivia());
-                    let new_ignored_comments = code.children_with_tokens().filter_map(|element| {
-                        element.as_token().and_then(|token| Comment::cast(token.clone()))
-                    });
-                    match_.ignored_comments.extend(new_ignored_comments);
-                    let match_from_children = pattern_children
-                        .by_ref()
-                        .zip(code_children.by_ref())
-                        .fold(Some(match_), |accum, (a, b)| {
-                            accum.and_then(|match_| check(&a, &b, placeholders, match_))
-                        });
-                    match_from_children.and_then(|match_| {
-                        if pattern_children.count() == 0 && code_children.count() == 0 {
-                            Some(match_)
-                        } else {
-                            None
-                        }
-                    })
+                    if let (Some(pattern), Some(code)) =
+                        (RecordLit::cast(pattern.clone()), RecordLit::cast(code.clone()))
+                    {
+                        check_record_lit(pattern, code, placeholders, match_)
+                    } else {
+                        let mut pattern_children = pattern
+                            .children_with_tokens()
+                            .filter(|element| !element.kind().is_trivia());
+                        let mut code_children = code
+                            .children_with_tokens()
+                            .filter(|element| !element.kind().is_trivia());
+                        let new_ignored_comments =
+                            code.children_with_tokens().filter_map(|element| {
+                                element.as_token().and_then(|token| Comment::cast(token.clone()))
+                            });
+                        match_.ignored_comments.extend(new_ignored_comments);
+                        pattern_children
+                            .by_ref()
+                            .zip(code_children.by_ref())
+                            .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/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 79dc03de4..a89ea86ea 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -21,7 +21,7 @@ use lsp_types::{
     WorkDoneProgressBegin, WorkDoneProgressCreateParams, WorkDoneProgressEnd,
     WorkDoneProgressReport,
 };
-use ra_flycheck::{url_from_path_with_drive_lowercasing, CheckConfig, CheckTask};
+use ra_flycheck::{url_from_path_with_drive_lowercasing, CheckTask, FlycheckConfig};
 use ra_ide::{Canceled, FileId, InlayHintsConfig, LibraryData, SourceRootId};
 use ra_prof::profile;
 use ra_vfs::{VfsFile, VfsTask, Watch};
@@ -102,10 +102,10 @@ fn get_config(
             max_length: config.inlay_hints_max_length,
         },
         check: if config.cargo_watch_enable {
-            Some(CheckConfig {
-                args: config.cargo_watch_args.clone(),
+            Some(FlycheckConfig::CargoCommand {
                 command: config.cargo_watch_command.clone(),
                 all_targets: config.cargo_watch_all_targets,
+                extra_args: config.cargo_watch_args.clone(),
             })
         } else {
             None
diff --git a/crates/rust-analyzer/src/world.rs b/crates/rust-analyzer/src/world.rs
index 7814a682e..2db058eb1 100644
--- a/crates/rust-analyzer/src/world.rs
+++ b/crates/rust-analyzer/src/world.rs
@@ -11,7 +11,7 @@ use std::{
 use crossbeam_channel::{unbounded, Receiver};
 use lsp_types::Url;
 use parking_lot::RwLock;
-use ra_flycheck::{url_from_path_with_drive_lowercasing, CheckConfig, Flycheck};
+use ra_flycheck::{url_from_path_with_drive_lowercasing, Flycheck, FlycheckConfig};
 use ra_ide::{
     Analysis, AnalysisChange, AnalysisHost, CrateGraph, FileId, InlayHintsConfig, LibraryData,
     SourceRootId,
@@ -58,7 +58,7 @@ pub struct Config {
     pub line_folding_only: bool,
     pub inlay_hints: InlayHintsConfig,
     pub rustfmt_args: Vec<String>,
-    pub check: Option<CheckConfig>,
+    pub check: Option<FlycheckConfig>,
     pub vscode_lldb: bool,
     pub proc_macro_srv: Option<String>,
 }