14 files changed, 252 insertions, 127 deletions

diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index df34dfdb8..c055d113d 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -49,12 +49,16 @@ jobs:
         node-version: 12.x
 
     - name: Dist
-      if: github.ref == 'refs/heads/release'
-      run: cargo xtask dist --version 0.2.$GITHUB_RUN_NUMBER         --tag $(date --iso --utc)
+      if: matrix.os == 'ubuntu-latest' && github.ref == 'refs/heads/release'
+      run: cargo xtask dist --client --version 0.2.$GITHUB_RUN_NUMBER         --tag $(date --iso --utc)
 
     - name: Dist
-      if: github.ref != 'refs/heads/release'
-      run: cargo xtask dist --version 0.3.$GITHUB_RUN_NUMBER-nightly --tag nightly
+      if: matrix.os == 'ubuntu-latest' && github.ref != 'refs/heads/release'
+      run: cargo xtask dist --client --version 0.3.$GITHUB_RUN_NUMBER-nightly --tag nightly
+
+    - name: Dist
+      if: matrix.os != 'ubuntu-latest'
+      run: cargo xtask dist
 
     - name: Upload artifacts
       uses: actions/upload-artifact@v1
diff --git a/crates/ra_cargo_watch/src/conv.rs b/crates/ra_cargo_watch/src/conv.rs
index c6f8ca329..817543deb 100644
--- a/crates/ra_cargo_watch/src/conv.rs
+++ b/crates/ra_cargo_watch/src/conv.rs
@@ -1,7 +1,8 @@
 //! This module provides the functionality needed to convert diagnostics from
 //! `cargo check` json format to the LSP diagnostic format.
 use cargo_metadata::diagnostic::{
-    Diagnostic as RustDiagnostic, DiagnosticLevel, DiagnosticSpan, DiagnosticSpanMacroExpansion,
+    Applicability, Diagnostic as RustDiagnostic, DiagnosticLevel, DiagnosticSpan,
+    DiagnosticSpanMacroExpansion,
 };
 use lsp_types::{
     CodeAction, Diagnostic, DiagnosticRelatedInformation, DiagnosticSeverity, DiagnosticTag,
@@ -136,10 +137,13 @@ fn map_rust_child_diagnostic(
 
     let mut edit_map: HashMap<Url, Vec<TextEdit>> = HashMap::new();
     for &span in &spans {
-        if let Some(suggested_replacement) = &span.suggested_replacement {
-            let location = map_span_to_location(span, workspace_root);
-            let edit = TextEdit::new(location.range, suggested_replacement.clone());
-            edit_map.entry(location.uri).or_default().push(edit);
+        match (&span.suggestion_applicability, &span.suggested_replacement) {
+            (Some(Applicability::MachineApplicable), Some(suggested_replacement)) => {
+                let location = map_span_to_location(span, workspace_root);
+                let edit = TextEdit::new(location.range, suggested_replacement.clone());
+                edit_map.entry(location.uri).or_default().push(edit);
+            }
+            _ => {}
         }
     }
 
diff --git a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_clippy_pass_by_ref.snap b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_clippy_pass_by_ref.snap
index 9e8f4eff4..a59fa84fa 100644
--- a/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_clippy_pass_by_ref.snap
+++ b/crates/ra_cargo_watch/src/conv/snapshots/ra_cargo_watch__conv__test__snap_clippy_pass_by_ref.snap
@@ -58,44 +58,26 @@ expression: diag
                         },
                         message: "lint level defined here",
                     },
+                    DiagnosticRelatedInformation {
+                        location: Location {
+                            uri: "file:///test/compiler/mir/tagset.rs",
+                            range: Range {
+                                start: Position {
+                                    line: 41,
+                                    character: 23,
+                                },
+                                end: Position {
+                                    line: 41,
+                                    character: 28,
+                                },
+                            },
+                        },
+                        message: "consider passing by value instead",
+                    },
                 ],
             ),
             tags: None,
         },
-        fixes: [
-            CodeAction {
-                title: "consider passing by value instead",
-                kind: Some(
-                    "quickfix",
-                ),
-                diagnostics: None,
-                edit: Some(
-                    WorkspaceEdit {
-                        changes: Some(
-                            {
-                                "file:///test/compiler/mir/tagset.rs": [
-                                    TextEdit {
-                                        range: Range {
-                                            start: Position {
-                                                line: 41,
-                                                character: 23,
-                                            },
-                                            end: Position {
-                                                line: 41,
-                                                character: 28,
-                                            },
-                                        },
-                                        new_text: "self",
-                                    },
-                                ],
-                            },
-                        ),
-                        document_changes: None,
-                    },
-                ),
-                command: None,
-                is_preferred: None,
-            },
-        ],
+        fixes: [],
     },
 ]
diff --git a/crates/ra_cargo_watch/src/lib.rs b/crates/ra_cargo_watch/src/lib.rs
index bffe5eb00..7c525c430 100644
--- a/crates/ra_cargo_watch/src/lib.rs
+++ b/crates/ra_cargo_watch/src/lib.rs
@@ -8,9 +8,10 @@ use lsp_types::{
     WorkDoneProgressEnd, WorkDoneProgressReport,
 };
 use std::{
+    error, fmt,
     io::{BufRead, BufReader},
     path::{Path, PathBuf},
-    process::{Child, Command, Stdio},
+    process::{Command, Stdio},
     thread::JoinHandle,
     time::Instant,
 };
@@ -70,10 +71,10 @@ 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 recv = self.cmd_send.take();
+            let cmd_send = self.cmd_send.take();
 
             // Dropping the sender finishes the thread loop
-            drop(recv);
+            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
@@ -246,11 +247,21 @@ 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 {}
+
 pub fn run_cargo(
     args: &[String],
     current_dir: Option<&Path>,
     on_message: &mut dyn FnMut(cargo_metadata::Message) -> bool,
-) -> Child {
+) -> Result<(), CargoError> {
     let mut command = Command::new("cargo");
     if let Some(current_dir) = current_dir {
         command.current_dir(current_dir);
@@ -273,6 +284,8 @@ pub fn run_cargo(
     // 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,
@@ -291,12 +304,31 @@ pub fn run_cargo(
             }
         };
 
+        read_at_least_one_message = true;
+
         if !on_message(message) {
             break;
         }
     }
 
-    child
+    // 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 {
@@ -325,7 +357,7 @@ impl WatchThread {
                 // which will break out of the loop, and continue the shutdown
                 let _ = message_send.send(CheckEvent::Begin);
 
-                let mut child = run_cargo(&args, Some(&workspace_root), &mut |message| {
+                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,
@@ -334,26 +366,19 @@ impl WatchThread {
                         _ => {}
                     }
 
-                    match message_send.send(CheckEvent::Msg(message)) {
-                        Ok(()) => {}
-                        Err(_err) => {
-                            // The send channel was closed, so we want to shutdown
-                            return false;
-                        }
-                    };
-
-                    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);
-
-                // It is okay to ignore the result, as it only errors if the process is already dead
-                let _ = child.kill();
-
-                // Again, we don't care about the exit status so just ignore the result
-                let _ = child.wait();
             }))
         } else {
             None
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 4b150ef06..e91abf6f5 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -10,7 +10,7 @@ use hir_def::{
     docs::Documentation,
     expr::{BindingAnnotation, Pat, PatId},
     per_ns::PerNs,
-    resolver::HasResolver,
+    resolver::{HasResolver, Resolver},
     type_ref::{Mutability, TypeRef},
     AdtId, AssocContainerId, ConstId, DefWithBodyId, EnumId, FunctionId, GenericDefId, HasModule,
     ImplId, LocalEnumVariantId, LocalModuleId, LocalStructFieldId, Lookup, ModuleId, StaticId,
@@ -912,10 +912,8 @@ impl Local {
         let def = DefWithBodyId::from(self.parent);
         let infer = db.infer(def);
         let ty = infer[self.pat_id].clone();
-        let resolver = def.resolver(db.upcast());
         let krate = def.module(db.upcast()).krate;
-        let environment = TraitEnvironment::lower(db, &resolver);
-        Type { krate, ty: InEnvironment { value: ty, environment } }
+        Type::new(db, krate, def, ty)
     }
 
     pub fn source(self, db: &dyn HirDatabase) -> InFile<Either<ast::BindPat, ast::SelfParam>> {
@@ -1020,11 +1018,21 @@ impl ImplDef {
 
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Type {
-    pub(crate) krate: CrateId,
-    pub(crate) ty: InEnvironment<Ty>,
+    krate: CrateId,
+    ty: InEnvironment<Ty>,
 }
 
 impl Type {
+    pub(crate) fn new_with_resolver(
+        db: &dyn HirDatabase,
+        resolver: &Resolver,
+        ty: Ty,
+    ) -> Option<Type> {
+        let krate = resolver.krate()?;
+        let environment = TraitEnvironment::lower(db, &resolver);
+        Some(Type { krate, ty: InEnvironment { value: ty, environment } })
+    }
+
     fn new(db: &dyn HirDatabase, krate: CrateId, lexical_env: impl HasResolver, ty: Ty) -> Type {
         let resolver = lexical_env.resolver(db.upcast());
         let environment = TraitEnvironment::lower(db, &resolver);
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 9f59d590c..713d45f48 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -4,6 +4,18 @@
 //! The principal difference between HIR and syntax trees is that HIR is bound
 //! to a particular crate instance. That is, it has cfg flags and features
 //! applied. So, the relation between syntax and HIR is many-to-one.
+//!
+//! HIR is the public API of the all of the compiler logic above syntax trees.
+//! It is written in "OO" style. Each type is self contained (as in, it knows it's
+//! parents and full context). It should be "clean code".
+//!
+//! `ra_hir_*` crates are the implementation of the compiler logic.
+//! They are written in "ECS" style, with relatively little abstractions.
+//! Many types are not self-contained, and explicitly use local indexes, arenas, etc.
+//!
+//! `ra_hir` is what insulates the "we don't know how to actually write an incremental compiler"
+//! from the ide with completions, hovers, etc. It is a (soft, internal) boundary:
+//! https://www.tedinski.com/2018/02/06/system-boundaries.html.
 
 #![recursion_limit = "512"]
 
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
index 55e634528..d982f6ffa 100644
--- a/crates/ra_hir/src/semantics.rs
+++ b/crates/ra_hir/src/semantics.rs
@@ -12,7 +12,8 @@ use hir_expand::ExpansionInfo;
 use ra_db::{FileId, FileRange};
 use ra_prof::profile;
 use ra_syntax::{
-    algo::skip_trivia_token, ast, AstNode, Direction, SyntaxNode, SyntaxToken, TextRange, TextUnit,
+    algo::{find_node_at_offset, skip_trivia_token},
+    ast, AstNode, Direction, SyntaxNode, SyntaxToken, TextRange, TextUnit,
 };
 use rustc_hash::{FxHashMap, FxHashSet};
 
@@ -108,6 +109,17 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
         token.value
     }
 
+    pub fn descend_node_at_offset<N: ast::AstNode>(
+        &self,
+        node: &SyntaxNode,
+        offset: TextUnit,
+    ) -> Option<N> {
+        // Handle macro token cases
+        node.token_at_offset(offset)
+            .map(|token| self.descend_into_macros(token))
+            .find_map(|it| self.ancestors_with_macros(it.parent()).find_map(N::cast))
+    }
+
     pub fn original_range(&self, node: &SyntaxNode) -> FileRange {
         let node = self.find_file(node.clone());
         original_range(self.db, node.as_ref())
@@ -129,6 +141,8 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
             .kmerge_by(|node1, node2| node1.text_range().len() < node2.text_range().len())
     }
 
+    /// Find a AstNode by offset inside SyntaxNode, if it is inside *Macrofile*,
+    /// search up until it is of the target AstNode type
     pub fn find_node_at_offset_with_macros<N: AstNode>(
         &self,
         node: &SyntaxNode,
@@ -137,6 +151,19 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> {
         self.ancestors_at_offset_with_macros(node, offset).find_map(N::cast)
     }
 
+    /// Find a AstNode by offset inside SyntaxNode, if it is inside *MacroCall*,
+    /// descend it and find again
+    pub fn find_node_at_offset_with_descend<N: AstNode>(
+        &self,
+        node: &SyntaxNode,
+        offset: TextUnit,
+    ) -> Option<N> {
+        if let Some(it) = find_node_at_offset(&node, offset) {
+            return Some(it);
+        }
+        self.descend_node_at_offset(&node, offset)
+    }
+
     pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
         self.analyze(expr.syntax()).type_of(self.db, &expr)
     }
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
index e8afef328..10c12c910 100644
--- a/crates/ra_hir/src/source_analyzer.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -17,7 +17,7 @@ use hir_def::{
     AsMacroCall, DefWithBodyId,
 };
 use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile};
-use hir_ty::{InEnvironment, InferenceResult, TraitEnvironment};
+use hir_ty::InferenceResult;
 use ra_syntax::{
     ast::{self, AstNode},
     SyntaxNode, SyntaxNodePtr, TextUnit,
@@ -103,10 +103,6 @@ impl SourceAnalyzer {
         Some(res)
     }
 
-    fn trait_env(&self, db: &dyn HirDatabase) -> Arc<TraitEnvironment> {
-        TraitEnvironment::lower(db, &self.resolver)
-    }
-
     pub(crate) fn type_of(&self, db: &dyn HirDatabase, expr: &ast::Expr) -> Option<Type> {
         let expr_id = match expr {
             ast::Expr::MacroCall(call) => {
@@ -117,15 +113,13 @@ impl SourceAnalyzer {
         }?;
 
         let ty = self.infer.as_ref()?[expr_id].clone();
-        let environment = self.trait_env(db);
-        Some(Type { krate: self.resolver.krate()?, ty: InEnvironment { value: ty, environment } })
+        Type::new_with_resolver(db, &self.resolver, ty)
     }
 
     pub(crate) fn type_of_pat(&self, db: &dyn HirDatabase, pat: &ast::Pat) -> Option<Type> {
         let pat_id = self.pat_id(pat)?;
         let ty = self.infer.as_ref()?[pat_id].clone();
-        let environment = self.trait_env(db);
-        Some(Type { krate: self.resolver.krate()?, ty: InEnvironment { value: ty, environment } })
+        Type::new_with_resolver(db, &self.resolver, ty)
     }
 
     pub(crate) fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs
index 3ea0ac230..746cc86ba 100644
--- a/crates/ra_ide/src/references.rs
+++ b/crates/ra_ide/src/references.rs
@@ -94,12 +94,16 @@ pub(crate) fn find_all_refs(
     let sema = Semantics::new(db);
     let syntax = sema.parse(position.file_id).syntax().clone();
 
-    let (opt_name, search_kind) =
-        if let Some(name) = get_struct_def_name_for_struct_literal_search(&syntax, position) {
-            (Some(name), ReferenceKind::StructLiteral)
-        } else {
-            (find_node_at_offset::<ast::Name>(&syntax, position.offset), ReferenceKind::Other)
-        };
+    let (opt_name, search_kind) = if let Some(name) =
+        get_struct_def_name_for_struct_literal_search(&sema, &syntax, position)
+    {
+        (Some(name), ReferenceKind::StructLiteral)
+    } else {
+        (
+            sema.find_node_at_offset_with_descend::<ast::Name>(&syntax, position.offset),
+            ReferenceKind::Other,
+        )
+    };
 
     let RangeInfo { range, info: def } = find_name(&sema, &syntax, position, opt_name)?;
 
@@ -131,7 +135,8 @@ fn find_name(
         let range = name.syntax().text_range();
         return Some(RangeInfo::new(range, def));
     }
-    let name_ref = find_node_at_offset::<ast::NameRef>(&syntax, position.offset)?;
+    let name_ref =
+        sema.find_node_at_offset_with_descend::<ast::NameRef>(&syntax, position.offset)?;
     let def = classify_name_ref(sema, &name_ref)?.definition();
     let range = name_ref.syntax().text_range();
     Some(RangeInfo::new(range, def))
@@ -157,6 +162,7 @@ fn decl_access(def: &Definition, syntax: &SyntaxNode, range: TextRange) -> Optio
 }
 
 fn get_struct_def_name_for_struct_literal_search(
+    sema: &Semantics<RootDatabase>,
     syntax: &SyntaxNode,
     position: FilePosition,
 ) -> Option<ast::Name> {
@@ -164,10 +170,18 @@ fn get_struct_def_name_for_struct_literal_search(
         if right.kind() != SyntaxKind::L_CURLY && right.kind() != SyntaxKind::L_PAREN {
             return None;
         }
-        if let Some(name) = find_node_at_offset::<ast::Name>(&syntax, left.text_range().start()) {
+        if let Some(name) =
+            sema.find_node_at_offset_with_descend::<ast::Name>(&syntax, left.text_range().start())
+        {
             return name.syntax().ancestors().find_map(ast::StructDef::cast).and_then(|l| l.name());
         }
-        if find_node_at_offset::<ast::TypeParamList>(&syntax, left.text_range().start()).is_some() {
+        if sema
+            .find_node_at_offset_with_descend::<ast::TypeParamList>(
+                &syntax,
+                left.text_range().start(),
+            )
+            .is_some()
+        {
             return left.ancestors().find_map(ast::StructDef::cast).and_then(|l| l.name());
         }
     }
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index 7d1190af9..9acc6158a 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -250,6 +250,63 @@ mod tests {
     }
 
     #[test]
+    fn test_rename_for_macro_args_rev() {
+        test_rename(
+            r#"
+    macro_rules! foo {($i:ident) => {$i} }
+    fn main() {
+        let a = "test";
+        foo!(a<|>);
+    }"#,
+            "b",
+            r#"
+    macro_rules! foo {($i:ident) => {$i} }
+    fn main() {
+        let b = "test";
+        foo!(b);
+    }"#,
+        );
+    }
+
+    #[test]
+    fn test_rename_for_macro_define_fn() {
+        test_rename(
+            r#"
+    macro_rules! define_fn {($id:ident) => { fn $id{} }}
+    define_fn!(foo);
+    fn main() {
+        fo<|>o();
+    }"#,
+            "bar",
+            r#"
+    macro_rules! define_fn {($id:ident) => { fn $id{} }}
+    define_fn!(bar);
+    fn main() {
+        bar();
+    }"#,
+        );
+    }
+
+    #[test]
+    fn test_rename_for_macro_define_fn_rev() {
+        test_rename(
+            r#"
+    macro_rules! define_fn {($id:ident) => { fn $id{} }}
+    define_fn!(fo<|>o);
+    fn main() {
+        foo();
+    }"#,
+            "bar",
+            r#"
+    macro_rules! define_fn {($id:ident) => { fn $id{} }}
+    define_fn!(bar);
+    fn main() {
+        bar();
+    }"#,
+        );
+    }
+
+    #[test]
     fn test_rename_for_param_inside() {
         test_rename(
             r#"
diff --git a/crates/ra_ide_db/src/search.rs b/crates/ra_ide_db/src/search.rs
index cf78d3e41..117454695 100644
--- a/crates/ra_ide_db/src/search.rs
+++ b/crates/ra_ide_db/src/search.rs
@@ -10,9 +10,7 @@ use hir::{DefWithBody, HasSource, ModuleSource, Semantics};
 use once_cell::unsync::Lazy;
 use ra_db::{FileId, FileRange, SourceDatabaseExt};
 use ra_prof::profile;
-use ra_syntax::{
-    algo::find_node_at_offset, ast, match_ast, AstNode, TextRange, TextUnit, TokenAtOffset,
-};
+use ra_syntax::{ast, match_ast, AstNode, TextRange, TextUnit};
 use rustc_hash::FxHashMap;
 use test_utils::tested_by;
 
@@ -219,21 +217,11 @@ impl Definition {
                     continue;
                 }
 
-                let name_ref =
-                    if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(&tree, offset) {
+                let name_ref: ast::NameRef =
+                    if let Some(name_ref) = sema.find_node_at_offset_with_descend(&tree, offset) {
                         name_ref
                     } else {
-                        // Handle macro token cases
-                        let token = match tree.token_at_offset(offset) {
-                            TokenAtOffset::None => continue,
-                            TokenAtOffset::Single(t) => t,
-                            TokenAtOffset::Between(_, t) => t,
-                        };
-                        let expanded = sema.descend_into_macros(token);
-                        match ast::NameRef::cast(expanded.parent()) {
-                            Some(name_ref) => name_ref,
-                            _ => continue,
-                        }
+                        continue;
                     };
 
                 // FIXME: reuse sb
diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs
index c2857dbfc..c7f9bd873 100644
--- a/crates/ra_project_model/src/cargo_workspace.rs
+++ b/crates/ra_project_model/src/cargo_workspace.rs
@@ -6,7 +6,7 @@ use std::{
 };
 
 use anyhow::{Context, Result};
-use cargo_metadata::{CargoOpt, Message, MetadataCommand, PackageId};
+use cargo_metadata::{BuildScript, CargoOpt, Message, MetadataCommand, PackageId};
 use ra_arena::{Arena, Idx};
 use ra_cargo_watch::run_cargo;
 use ra_db::Edition;
@@ -254,7 +254,7 @@ pub fn load_out_dirs(
         "check".to_string(),
         "--message-format=json".to_string(),
         "--manifest-path".to_string(),
-        format!("{}", cargo_toml.display()),
+        cargo_toml.display().to_string(),
     ];
 
     if cargo_features.all_features {
@@ -263,19 +263,15 @@ pub fn load_out_dirs(
         // FIXME: `NoDefaultFeatures` is mutual exclusive with `SomeFeatures`
         // https://github.com/oli-obk/cargo_metadata/issues/79
         args.push("--no-default-features".to_string());
-    } else if !cargo_features.features.is_empty() {
-        for feature in &cargo_features.features {
-            args.push(feature.clone());
-        }
+    } else {
+        args.extend(cargo_features.features.iter().cloned());
     }
 
-    let mut res = FxHashMap::default();
-    let mut child = run_cargo(&args, cargo_toml.parent(), &mut |message| {
+    let mut acc = FxHashMap::default();
+    let res = run_cargo(&args, cargo_toml.parent(), &mut |message| {
         match message {
-            Message::BuildScriptExecuted(message) => {
-                let package_id = message.package_id;
-                let out_dir = message.out_dir;
-                res.insert(package_id, out_dir);
+            Message::BuildScriptExecuted(BuildScript { package_id, out_dir, .. }) => {
+                acc.insert(package_id, out_dir);
             }
 
             Message::CompilerArtifact(_) => (),
@@ -285,6 +281,9 @@ pub fn load_out_dirs(
         true
     });
 
-    let _ = child.wait();
-    res
+    if let Err(err) = res {
+        log::error!("Failed to load outdirs: {:?}", err);
+    }
+
+    acc
 }
diff --git a/xtask/src/dist.rs b/xtask/src/dist.rs
index 2002d3e2a..3255eefb9 100644
--- a/xtask/src/dist.rs
+++ b/xtask/src/dist.rs
@@ -7,13 +7,18 @@ use crate::{
     project_root,
 };
 
-pub fn run_dist(version: &str, release_tag: &str) -> Result<()> {
+pub struct ClientOpts {
+    pub version: String,
+    pub release_tag: String,
+}
+
+pub fn run_dist(client_opts: Option<ClientOpts>) -> Result<()> {
     let dist = project_root().join("dist");
     rm_rf(&dist)?;
     fs2::create_dir_all(&dist)?;
 
-    if cfg!(target_os = "linux") {
-        dist_client(version, release_tag)?;
+    if let Some(ClientOpts { version, release_tag }) = client_opts {
+        dist_client(&version, &release_tag)?;
     }
     dist_server()?;
     Ok(())
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index aafa73610..a9adcfba4 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -13,7 +13,7 @@ use std::env;
 use pico_args::Arguments;
 use xtask::{
     codegen::{self, Mode},
-    dist::run_dist,
+    dist::{run_dist, ClientOpts},
     install::{ClientOpt, InstallCmd, ServerOpt},
     not_bash::pushd,
     pre_commit, project_root, run_clippy, run_fuzzer, run_pre_cache, run_release, run_rustfmt,
@@ -103,10 +103,16 @@ FLAGS:
             run_release(dry_run)
         }
         "dist" => {
-            let version: String = args.value_from_str("--version")?;
-            let release_tag: String = args.value_from_str("--tag")?;
+            let client_opts = if args.contains("--client") {
+                Some(ClientOpts {
+                    version: args.value_from_str("--version")?,
+                    release_tag: args.value_from_str("--tag")?,
+                })
+            } else {
+                None
+            };
             args.finish()?;
-            run_dist(&version, &release_tag)
+            run_dist(client_opts)
         }
         _ => {
             eprintln!(