1 files changed, 53 insertions, 55 deletions

diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index e7da683d6..9b30bef8d 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -8,7 +8,7 @@ use std::{
     fs::{read_dir, File, ReadDir},
     io::{self, BufReader},
     path::{Path, PathBuf},
-    process::Command,
+    process::{Command, Output},
 };
 
 use anyhow::{bail, Context, Result};
@@ -35,7 +35,7 @@ pub enum ProjectWorkspace {
 /// `PackageRoot` describes a package root folder.
 /// Which may be an external dependency, or a member of
 /// the current workspace.
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct PackageRoot {
     /// Path to the root folder
     path: PathBuf,
@@ -88,46 +88,28 @@ impl ProjectRoot {
     }
 
     pub fn discover(path: &Path) -> io::Result<Vec<ProjectRoot>> {
-        if let Some(project_json) = find_rust_project_json(path) {
+        if let Some(project_json) = find_in_parent_dirs(path, "rust-project.json") {
             return Ok(vec![ProjectRoot::ProjectJson(project_json)]);
         }
         return find_cargo_toml(path)
             .map(|paths| paths.into_iter().map(ProjectRoot::CargoToml).collect());
 
-        fn find_rust_project_json(path: &Path) -> Option<PathBuf> {
-            if path.ends_with("rust-project.json") {
-                return Some(path.to_path_buf());
-            }
-
-            let mut curr = Some(path);
-            while let Some(path) = curr {
-                let candidate = path.join("rust-project.json");
-                if candidate.exists() {
-                    return Some(candidate);
-                }
-                curr = path.parent();
-            }
-
-            None
-        }
-
         fn find_cargo_toml(path: &Path) -> io::Result<Vec<PathBuf>> {
-            if path.ends_with("Cargo.toml") {
-                return Ok(vec![path.to_path_buf()]);
+            match find_in_parent_dirs(path, "Cargo.toml") {
+                Some(it) => Ok(vec![it]),
+                None => Ok(find_cargo_toml_in_child_dir(read_dir(path)?)),
             }
+        }
 
-            if let Some(p) = find_cargo_toml_in_parent_dir(path) {
-                return Ok(vec![p]);
+        fn find_in_parent_dirs(path: &Path, target_file_name: &str) -> Option<PathBuf> {
+            if path.ends_with(target_file_name) {
+                return Some(path.to_owned());
             }
 
-            let entities = read_dir(path)?;
-            Ok(find_cargo_toml_in_child_dir(entities))
-        }
-
-        fn find_cargo_toml_in_parent_dir(path: &Path) -> Option<PathBuf> {
             let mut curr = Some(path);
+
             while let Some(path) = curr {
-                let candidate = path.join("Cargo.toml");
+                let candidate = path.join(target_file_name);
                 if candidate.exists() {
                     return Some(candidate);
                 }
@@ -139,14 +121,11 @@ impl ProjectRoot {
 
         fn find_cargo_toml_in_child_dir(entities: ReadDir) -> Vec<PathBuf> {
             // Only one level down to avoid cycles the easy way and stop a runaway scan with large projects
-            let mut valid_canditates = vec![];
-            for entity in entities.filter_map(Result::ok) {
-                let candidate = entity.path().join("Cargo.toml");
-                if candidate.exists() {
-                    valid_canditates.push(candidate)
-                }
-            }
-            valid_canditates
+            entities
+                .filter_map(Result::ok)
+                .map(|it| it.path().join("Cargo.toml"))
+                .filter(|it| it.exists())
+                .collect()
         }
     }
 }
@@ -408,7 +387,18 @@ impl ProjectWorkspace {
                             let edition = cargo[pkg].edition;
                             let cfg_options = {
                                 let mut opts = default_cfg_options.clone();
-                                opts.insert_features(cargo[pkg].features.iter().map(Into::into));
+                                for feature in cargo[pkg].features.iter() {
+                                    opts.insert_key_value("feature".into(), feature.into());
+                                }
+                                for cfg in cargo[pkg].cfgs.iter() {
+                                    match cfg.find('=') {
+                                        Some(split) => opts.insert_key_value(
+                                            cfg[..split].into(),
+                                            cfg[split + 1..].trim_matches('"').into(),
+                                        ),
+                                        None => opts.insert_atom(cfg.into()),
+                                    };
+                                }
                                 opts
                             };
                             let mut env = Env::default();
@@ -553,7 +543,7 @@ impl ProjectWorkspace {
     }
 }
 
-pub fn get_rustc_cfg_options() -> CfgOptions {
+pub fn get_rustc_cfg_options(target: Option<&String>) -> CfgOptions {
     let mut cfg_options = CfgOptions::default();
 
     // Some nightly-only cfgs, which are required for stdlib
@@ -566,23 +556,18 @@ pub fn get_rustc_cfg_options() -> CfgOptions {
         }
     }
 
-    match (|| -> Result<String> {
+    let rustc_cfgs = || -> Result<String> {
         // `cfg(test)` and `cfg(debug_assertion)` are handled outside, so we suppress them here.
-        let output = Command::new("rustc")
-            .args(&["--print", "cfg", "-O"])
-            .output()
-            .context("Failed to get output from rustc --print cfg -O")?;
-        if !output.status.success() {
-            bail!(
-                "rustc --print cfg -O exited with exit code ({})",
-                output
-                    .status
-                    .code()
-                    .map_or(String::from("no exit code"), |code| format!("{}", code))
-            );
+        let mut cmd = Command::new(ra_toolchain::rustc());
+        cmd.args(&["--print", "cfg", "-O"]);
+        if let Some(target) = target {
+            cmd.args(&["--target", target.as_str()]);
         }
+        let output = output(cmd)?;
         Ok(String::from_utf8(output.stdout)?)
-    })() {
+    }();
+
+    match rustc_cfgs {
         Ok(rustc_cfgs) => {
             for line in rustc_cfgs.lines() {
                 match line.find('=') {
@@ -595,8 +580,21 @@ pub fn get_rustc_cfg_options() -> CfgOptions {
                 }
             }
         }
-        Err(e) => log::error!("failed to get rustc cfgs: {}", e),
+        Err(e) => log::error!("failed to get rustc cfgs: {:#}", e),
     }
 
     cfg_options
 }
+
+fn output(mut cmd: Command) -> Result<Output> {
+    let output = cmd.output().with_context(|| format!("{:?} failed", cmd))?;
+    if !output.status.success() {
+        match String::from_utf8(output.stderr) {
+            Ok(stderr) if !stderr.is_empty() => {
+                bail!("{:?} failed, {}\nstderr:\n{}", cmd, output.status, stderr)
+            }
+            _ => bail!("{:?} failed, {}", cmd, output.status),
+        }
+    }
+    Ok(output)
+}