6 files changed, 399 insertions, 239 deletions

diff --git a/crates/project_model/Cargo.toml b/crates/project_model/Cargo.toml
index 293cb5bfe..fe3258332 100644
--- a/crates/project_model/Cargo.toml
+++ b/crates/project_model/Cargo.toml
@@ -12,7 +12,7 @@ doctest = false
 [dependencies]
 log = "0.4.8"
 rustc-hash = "1.1.0"
-cargo_metadata = "0.12.2"
+cargo_metadata = "0.13"
 serde = { version = "1.0.106", features = ["derive"] }
 serde_json = "1.0.48"
 anyhow = "1.0.26"
@@ -22,7 +22,7 @@ la-arena = { version = "0.2.0", path = "../../lib/arena" }
 cfg = { path = "../cfg", version = "0.0.0" }
 base_db = { path = "../base_db", version = "0.0.0" }
 toolchain = { path = "../toolchain", version = "0.0.0" }
-proc_macro_api =  { path = "../proc_macro_api", version = "0.0.0" }
-paths =  { path = "../paths", version = "0.0.0" }
-stdx =  { path = "../stdx", version = "0.0.0" }
-profile =  { path = "../profile", version = "0.0.0" }
+proc_macro_api = { path = "../proc_macro_api", version = "0.0.0" }
+paths = { path = "../paths", version = "0.0.0" }
+stdx = { path = "../stdx", version = "0.0.0" }
+profile = { path = "../profile", version = "0.0.0" }
diff --git a/crates/project_model/src/build_data.rs b/crates/project_model/src/build_data.rs
new file mode 100644
index 000000000..728a258ea
--- /dev/null
+++ b/crates/project_model/src/build_data.rs
@@ -0,0 +1,254 @@
+//! Handles build script specific information
+
+use std::{
+    io::BufReader,
+    path::PathBuf,
+    process::{Command, Stdio},
+    sync::Arc,
+};
+
+use anyhow::Result;
+use cargo_metadata::camino::Utf8Path;
+use cargo_metadata::{BuildScript, Message};
+use itertools::Itertools;
+use paths::{AbsPath, AbsPathBuf};
+use rustc_hash::FxHashMap;
+use stdx::JodChild;
+
+use crate::{cfg_flag::CfgFlag, CargoConfig};
+
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub(crate) struct BuildData {
+    /// List of config flags defined by this package's build script
+    pub(crate) cfgs: Vec<CfgFlag>,
+    /// List of cargo-related environment variables with their value
+    ///
+    /// If the package has a build script which defines environment variables,
+    /// they can also be found here.
+    pub(crate) envs: Vec<(String, String)>,
+    /// Directory where a build script might place its output
+    pub(crate) out_dir: Option<AbsPathBuf>,
+    /// Path to the proc-macro library file if this package exposes proc-macros
+    pub(crate) proc_macro_dylib_path: Option<AbsPathBuf>,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct BuildDataConfig {
+    cargo_toml: AbsPathBuf,
+    cargo_features: CargoConfig,
+    packages: Arc<Vec<cargo_metadata::Package>>,
+}
+
+impl PartialEq for BuildDataConfig {
+    fn eq(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.packages, &other.packages)
+    }
+}
+
+impl Eq for BuildDataConfig {}
+
+#[derive(Debug, Default)]
+pub struct BuildDataCollector {
+    configs: FxHashMap<AbsPathBuf, BuildDataConfig>,
+}
+
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct BuildDataResult {
+    data: FxHashMap<AbsPathBuf, BuildDataMap>,
+}
+
+pub(crate) type BuildDataMap = FxHashMap<String, BuildData>;
+
+impl BuildDataCollector {
+    pub(crate) fn add_config(&mut self, workspace_root: &AbsPath, config: BuildDataConfig) {
+        self.configs.insert(workspace_root.to_path_buf(), config);
+    }
+
+    pub fn collect(&mut self, progress: &dyn Fn(String)) -> Result<BuildDataResult> {
+        let mut res = BuildDataResult::default();
+        for (path, config) in self.configs.iter() {
+            res.data.insert(
+                path.clone(),
+                collect_from_workspace(
+                    &config.cargo_toml,
+                    &config.cargo_features,
+                    &config.packages,
+                    progress,
+                )?,
+            );
+        }
+        Ok(res)
+    }
+}
+
+impl BuildDataResult {
+    pub(crate) fn get(&self, root: &AbsPath) -> Option<&BuildDataMap> {
+        self.data.get(&root.to_path_buf())
+    }
+}
+
+impl BuildDataConfig {
+    pub(crate) fn new(
+        cargo_toml: AbsPathBuf,
+        cargo_features: CargoConfig,
+        packages: Arc<Vec<cargo_metadata::Package>>,
+    ) -> Self {
+        Self { cargo_toml, cargo_features, packages }
+    }
+}
+
+fn collect_from_workspace(
+    cargo_toml: &AbsPath,
+    cargo_features: &CargoConfig,
+    packages: &Vec<cargo_metadata::Package>,
+    progress: &dyn Fn(String),
+) -> Result<BuildDataMap> {
+    let mut cmd = Command::new(toolchain::cargo());
+    cmd.args(&["check", "--workspace", "--message-format=json", "--manifest-path"])
+        .arg(cargo_toml.as_ref());
+
+    // --all-targets includes tests, benches and examples in addition to the
+    // default lib and bins. This is an independent concept from the --targets
+    // flag below.
+    cmd.arg("--all-targets");
+
+    if let Some(target) = &cargo_features.target {
+        cmd.args(&["--target", target]);
+    }
+
+    if cargo_features.all_features {
+        cmd.arg("--all-features");
+    } else {
+        if cargo_features.no_default_features {
+            // FIXME: `NoDefaultFeatures` is mutual exclusive with `SomeFeatures`
+            // https://github.com/oli-obk/cargo_metadata/issues/79
+            cmd.arg("--no-default-features");
+        }
+        if !cargo_features.features.is_empty() {
+            cmd.arg("--features");
+            cmd.arg(cargo_features.features.join(" "));
+        }
+    }
+
+    cmd.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null());
+
+    let mut child = cmd.spawn().map(JodChild)?;
+    let child_stdout = child.stdout.take().unwrap();
+    let stdout = BufReader::new(child_stdout);
+
+    let mut res = BuildDataMap::default();
+    for message in cargo_metadata::Message::parse_stream(stdout) {
+        if let Ok(message) = message {
+            match message {
+                Message::BuildScriptExecuted(BuildScript {
+                    package_id,
+                    out_dir,
+                    cfgs,
+                    env,
+                    ..
+                }) => {
+                    let cfgs = {
+                        let mut acc = Vec::new();
+                        for cfg in cfgs {
+                            match cfg.parse::<CfgFlag>() {
+                                Ok(it) => acc.push(it),
+                                Err(err) => {
+                                    anyhow::bail!("invalid cfg from cargo-metadata: {}", err)
+                                }
+                            };
+                        }
+                        acc
+                    };
+                    let res = res.entry(package_id.repr.clone()).or_default();
+                    // cargo_metadata crate returns default (empty) path for
+                    // older cargos, which is not absolute, so work around that.
+                    if !out_dir.as_str().is_empty() {
+                        let out_dir = AbsPathBuf::assert(PathBuf::from(out_dir.into_os_string()));
+                        res.out_dir = Some(out_dir);
+                        res.cfgs = cfgs;
+                    }
+
+                    res.envs = env;
+                }
+                Message::CompilerArtifact(message) => {
+                    progress(format!("metadata {}", message.target.name));
+
+                    if message.target.kind.contains(&"proc-macro".to_string()) {
+                        let package_id = message.package_id;
+                        // Skip rmeta file
+                        if let Some(filename) = message.filenames.iter().find(|name| is_dylib(name))
+                        {
+                            let filename = AbsPathBuf::assert(PathBuf::from(&filename));
+                            let res = res.entry(package_id.repr.clone()).or_default();
+                            res.proc_macro_dylib_path = Some(filename);
+                        }
+                    }
+                }
+                Message::CompilerMessage(message) => {
+                    progress(message.target.name.clone());
+                }
+                Message::BuildFinished(_) => {}
+                Message::TextLine(_) => {}
+                _ => {}
+            }
+        }
+    }
+
+    for package in packages {
+        let build_data = res.entry(package.id.repr.clone()).or_default();
+        inject_cargo_env(package, build_data);
+        if let Some(out_dir) = &build_data.out_dir {
+            // NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!()
+            if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) {
+                build_data.envs.push(("OUT_DIR".to_string(), out_dir));
+            }
+        }
+    }
+
+    Ok(res)
+}
+
+// FIXME: File a better way to know if it is a dylib
+fn is_dylib(path: &Utf8Path) -> bool {
+    match path.extension().map(|e| e.to_string().to_lowercase()) {
+        None => false,
+        Some(ext) => matches!(ext.as_str(), "dll" | "dylib" | "so"),
+    }
+}
+
+/// Recreates the compile-time environment variables that Cargo sets.
+///
+/// Should be synced with <https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-crates>
+fn inject_cargo_env(package: &cargo_metadata::Package, build_data: &mut BuildData) {
+    let env = &mut build_data.envs;
+
+    // FIXME: Missing variables:
+    // CARGO_PKG_HOMEPAGE, CARGO_CRATE_NAME, CARGO_BIN_NAME, CARGO_BIN_EXE_<name>
+
+    let mut manifest_dir = package.manifest_path.clone();
+    manifest_dir.pop();
+    env.push(("CARGO_MANIFEST_DIR".into(), manifest_dir.into_string()));
+
+    // Not always right, but works for common cases.
+    env.push(("CARGO".into(), "cargo".into()));
+
+    env.push(("CARGO_PKG_VERSION".into(), package.version.to_string()));
+    env.push(("CARGO_PKG_VERSION_MAJOR".into(), package.version.major.to_string()));
+    env.push(("CARGO_PKG_VERSION_MINOR".into(), package.version.minor.to_string()));
+    env.push(("CARGO_PKG_VERSION_PATCH".into(), package.version.patch.to_string()));
+
+    let pre = package.version.pre.iter().map(|id| id.to_string()).format(".");
+    env.push(("CARGO_PKG_VERSION_PRE".into(), pre.to_string()));
+
+    let authors = package.authors.join(";");
+    env.push(("CARGO_PKG_AUTHORS".into(), authors));
+
+    env.push(("CARGO_PKG_NAME".into(), package.name.clone()));
+    env.push(("CARGO_PKG_DESCRIPTION".into(), package.description.clone().unwrap_or_default()));
+    //env.push(("CARGO_PKG_HOMEPAGE".into(), package.homepage.clone().unwrap_or_default()));
+    env.push(("CARGO_PKG_REPOSITORY".into(), package.repository.clone().unwrap_or_default()));
+    env.push(("CARGO_PKG_LICENSE".into(), package.license.clone().unwrap_or_default()));
+
+    let license_file = package.license_file.as_ref().map(|buf| buf.to_string()).unwrap_or_default();
+    env.push(("CARGO_PKG_LICENSE_FILE".into(), license_file));
+}
diff --git a/crates/project_model/src/cargo_workspace.rs b/crates/project_model/src/cargo_workspace.rs
index c0ed37fc1..f7241b711 100644
--- a/crates/project_model/src/cargo_workspace.rs
+++ b/crates/project_model/src/cargo_workspace.rs
@@ -1,24 +1,16 @@
 //! FIXME: write short doc here
 
-use std::{
-    convert::TryInto,
-    ffi::OsStr,
-    io::BufReader,
-    ops,
-    path::{Path, PathBuf},
-    process::{Command, Stdio},
-};
+use std::path::PathBuf;
+use std::{convert::TryInto, ops, process::Command, sync::Arc};
 
 use anyhow::{Context, Result};
 use base_db::Edition;
-use cargo_metadata::{BuildScript, CargoOpt, Message, MetadataCommand, PackageId};
-use itertools::Itertools;
+use cargo_metadata::{CargoOpt, MetadataCommand};
 use la_arena::{Arena, Idx};
 use paths::{AbsPath, AbsPathBuf};
 use rustc_hash::FxHashMap;
-use stdx::JodChild;
 
-use crate::cfg_flag::CfgFlag;
+use crate::build_data::BuildDataConfig;
 use crate::utf8_stdout;
 
 /// `CargoWorkspace` represents the logical structure of, well, a Cargo
@@ -36,6 +28,7 @@ pub struct CargoWorkspace {
     packages: Arena<PackageData>,
     targets: Arena<TargetData>,
     workspace_root: AbsPathBuf,
+    build_data_config: BuildDataConfig,
 }
 
 impl ops::Index<Package> for CargoWorkspace {
@@ -52,6 +45,15 @@ impl ops::Index<Target> for CargoWorkspace {
     }
 }
 
+/// Describes how to set the rustc source directory.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum RustcSource {
+    /// Explicit path for the rustc source directory.
+    Path(AbsPathBuf),
+    /// Try to automatically detect where the rustc source directory is.
+    Discover,
+}
+
 #[derive(Default, Clone, Debug, PartialEq, Eq)]
 pub struct CargoConfig {
     /// Do not activate the `default` feature.
@@ -64,9 +66,6 @@ pub struct CargoConfig {
     /// This will be ignored if `cargo_all_features` is true.
     pub features: Vec<String>,
 
-    /// Runs cargo check on launch to figure out the correct values of OUT_DIR
-    pub load_out_dirs_from_check: bool,
-
     /// rustc target
     pub target: Option<String>,
 
@@ -75,7 +74,7 @@ pub struct CargoConfig {
     pub no_sysroot: bool,
 
     /// rustc private crate source
-    pub rustc_source: Option<AbsPathBuf>,
+    pub rustc_source: Option<RustcSource>,
 }
 
 pub type Package = Idx<PackageData>;
@@ -99,19 +98,12 @@ pub struct PackageData {
     pub dependencies: Vec<PackageDependency>,
     /// Rust edition for this package
     pub edition: Edition,
-    /// List of features to activate
-    pub features: Vec<String>,
-    /// List of config flags defined by this package's build script
-    pub cfgs: Vec<CfgFlag>,
-    /// List of cargo-related environment variables with their value
-    ///
-    /// If the package has a build script which defines environment variables,
-    /// they can also be found here.
-    pub envs: Vec<(String, String)>,
-    /// Directory where a build script might place its output
-    pub out_dir: Option<AbsPathBuf>,
-    /// Path to the proc-macro library file if this package exposes proc-macros
-    pub proc_macro_dylib_path: Option<AbsPathBuf>,
+    /// Features provided by the crate, mapped to the features required by that feature.
+    pub features: FxHashMap<String, Vec<String>>,
+    /// List of features enabled on this package
+    pub active_features: Vec<String>,
+    // String representation of package id
+    pub id: String,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -244,18 +236,6 @@ impl CargoWorkspace {
             )
         })?;
 
-        let mut out_dir_by_id = FxHashMap::default();
-        let mut cfgs = FxHashMap::default();
-        let mut envs = FxHashMap::default();
-        let mut proc_macro_dylib_paths = FxHashMap::default();
-        if config.load_out_dirs_from_check {
-            let resources = load_extern_resources(cargo_toml, config, progress)?;
-            out_dir_by_id = resources.out_dirs;
-            cfgs = resources.cfgs;
-            envs = resources.env;
-            proc_macro_dylib_paths = resources.proc_dylib_paths;
-        }
-
         let mut pkg_by_id = FxHashMap::default();
         let mut packages = Arena::default();
         let mut targets = Arena::default();
@@ -263,38 +243,34 @@ impl CargoWorkspace {
         let ws_members = &meta.workspace_members;
 
         meta.packages.sort_by(|a, b| a.id.cmp(&b.id));
-        for meta_pkg in meta.packages {
-            let id = meta_pkg.id.clone();
-            inject_cargo_env(&meta_pkg, envs.entry(id).or_default());
-
+        for meta_pkg in &meta.packages {
             let cargo_metadata::Package { id, edition, name, manifest_path, version, .. } =
                 meta_pkg;
             let is_member = ws_members.contains(&id);
             let edition = edition
                 .parse::<Edition>()
                 .with_context(|| format!("Failed to parse edition {}", edition))?;
+
             let pkg = packages.alloc(PackageData {
-                name,
+                id: id.repr.clone(),
+                name: name.clone(),
                 version: version.to_string(),
-                manifest: AbsPathBuf::assert(manifest_path),
+                manifest: AbsPathBuf::assert(PathBuf::from(&manifest_path)),
                 targets: Vec::new(),
                 is_member,
                 edition,
                 dependencies: Vec::new(),
-                features: Vec::new(),
-                cfgs: cfgs.get(&id).cloned().unwrap_or_default(),
-                envs: envs.get(&id).cloned().unwrap_or_default(),
-                out_dir: out_dir_by_id.get(&id).cloned(),
-                proc_macro_dylib_path: proc_macro_dylib_paths.get(&id).cloned(),
+                features: meta_pkg.features.clone().into_iter().collect(),
+                active_features: Vec::new(),
             });
             let pkg_data = &mut packages[pkg];
             pkg_by_id.insert(id, pkg);
-            for meta_tgt in meta_pkg.targets {
+            for meta_tgt in &meta_pkg.targets {
                 let is_proc_macro = meta_tgt.kind.as_slice() == ["proc-macro"];
                 let tgt = targets.alloc(TargetData {
                     package: pkg,
-                    name: meta_tgt.name,
-                    root: AbsPathBuf::assert(meta_tgt.src_path.clone()),
+                    name: meta_tgt.name.clone(),
+                    root: AbsPathBuf::assert(PathBuf::from(&meta_tgt.src_path)),
                     kind: TargetKind::new(meta_tgt.kind.as_slice()),
                     is_proc_macro,
                 });
@@ -328,11 +304,18 @@ impl CargoWorkspace {
                 let dep = PackageDependency { name: dep_node.name, pkg };
                 packages[source].dependencies.push(dep);
             }
-            packages[source].features.extend(node.features);
+            packages[source].active_features.extend(node.features);
         }
 
-        let workspace_root = AbsPathBuf::assert(meta.workspace_root);
-        Ok(CargoWorkspace { packages, targets, workspace_root: workspace_root })
+        let workspace_root =
+            AbsPathBuf::assert(PathBuf::from(meta.workspace_root.into_os_string()));
+        let build_data_config = BuildDataConfig::new(
+            cargo_toml.to_path_buf(),
+            config.clone(),
+            Arc::new(meta.packages.clone()),
+        );
+
+        Ok(CargoWorkspace { packages, targets, workspace_root, build_data_config })
     }
 
     pub fn packages<'a>(&'a self) -> impl Iterator<Item = Package> + ExactSizeIterator + 'a {
@@ -358,153 +341,11 @@ impl CargoWorkspace {
         }
     }
 
-    fn is_unique(&self, name: &str) -> bool {
-        self.packages.iter().filter(|(_, v)| v.name == name).count() == 1
-    }
-}
-
-#[derive(Debug, Clone, Default)]
-pub(crate) struct ExternResources {
-    out_dirs: FxHashMap<PackageId, AbsPathBuf>,
-    proc_dylib_paths: FxHashMap<PackageId, AbsPathBuf>,
-    cfgs: FxHashMap<PackageId, Vec<CfgFlag>>,
-    env: FxHashMap<PackageId, Vec<(String, String)>>,
-}
-
-pub(crate) fn load_extern_resources(
-    cargo_toml: &Path,
-    cargo_features: &CargoConfig,
-    progress: &dyn Fn(String),
-) -> Result<ExternResources> {
-    let mut cmd = Command::new(toolchain::cargo());
-    cmd.args(&["check", "--workspace", "--message-format=json", "--manifest-path"]).arg(cargo_toml);
-
-    // --all-targets includes tests, benches and examples in addition to the
-    // default lib and bins. This is an independent concept from the --targets
-    // flag below.
-    cmd.arg("--all-targets");
-
-    if let Some(target) = &cargo_features.target {
-        cmd.args(&["--target", target]);
-    }
-
-    if cargo_features.all_features {
-        cmd.arg("--all-features");
-    } else {
-        if cargo_features.no_default_features {
-            // FIXME: `NoDefaultFeatures` is mutual exclusive with `SomeFeatures`
-            // https://github.com/oli-obk/cargo_metadata/issues/79
-            cmd.arg("--no-default-features");
-        }
-        if !cargo_features.features.is_empty() {
-            cmd.arg("--features");
-            cmd.arg(cargo_features.features.join(" "));
-        }
-    }
-
-    cmd.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null());
-
-    let mut child = cmd.spawn().map(JodChild)?;
-    let child_stdout = child.stdout.take().unwrap();
-    let stdout = BufReader::new(child_stdout);
-
-    let mut res = ExternResources::default();
-    for message in cargo_metadata::Message::parse_stream(stdout) {
-        if let Ok(message) = message {
-            match message {
-                Message::BuildScriptExecuted(BuildScript {
-                    package_id,
-                    out_dir,
-                    cfgs,
-                    env,
-                    ..
-                }) => {
-                    let cfgs = {
-                        let mut acc = Vec::new();
-                        for cfg in cfgs {
-                            match cfg.parse::<CfgFlag>() {
-                                Ok(it) => acc.push(it),
-                                Err(err) => {
-                                    anyhow::bail!("invalid cfg from cargo-metadata: {}", err)
-                                }
-                            };
-                        }
-                        acc
-                    };
-                    // cargo_metadata crate returns default (empty) path for
-                    // older cargos, which is not absolute, so work around that.
-                    if out_dir != PathBuf::default() {
-                        let out_dir = AbsPathBuf::assert(out_dir);
-                        res.out_dirs.insert(package_id.clone(), out_dir);
-                        res.cfgs.insert(package_id.clone(), cfgs);
-                    }
-
-                    res.env.insert(package_id, env);
-                }
-                Message::CompilerArtifact(message) => {
-                    progress(format!("metadata {}", message.target.name));
-
-                    if message.target.kind.contains(&"proc-macro".to_string()) {
-                        let package_id = message.package_id;
-                        // Skip rmeta file
-                        if let Some(filename) = message.filenames.iter().find(|name| is_dylib(name))
-                        {
-                            let filename = AbsPathBuf::assert(filename.clone());
-                            res.proc_dylib_paths.insert(package_id, filename);
-                        }
-                    }
-                }
-                Message::CompilerMessage(message) => {
-                    progress(message.target.name.clone());
-                }
-                Message::Unknown => (),
-                Message::BuildFinished(_) => {}
-                Message::TextLine(_) => {}
-            }
-        }
+    pub(crate) fn build_data_config(&self) -> &BuildDataConfig {
+        &self.build_data_config
     }
-    Ok(res)
-}
 
-// FIXME: File a better way to know if it is a dylib
-fn is_dylib(path: &Path) -> bool {
-    match path.extension().and_then(OsStr::to_str).map(|it| it.to_string().to_lowercase()) {
-        None => false,
-        Some(ext) => matches!(ext.as_str(), "dll" | "dylib" | "so"),
-    }
-}
-
-/// Recreates the compile-time environment variables that Cargo sets.
-///
-/// Should be synced with <https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-crates>
-fn inject_cargo_env(package: &cargo_metadata::Package, env: &mut Vec<(String, String)>) {
-    // FIXME: Missing variables:
-    // CARGO, CARGO_PKG_HOMEPAGE, CARGO_CRATE_NAME, CARGO_BIN_NAME, CARGO_BIN_EXE_<name>
-
-    let mut manifest_dir = package.manifest_path.clone();
-    manifest_dir.pop();
-    if let Some(cargo_manifest_dir) = manifest_dir.to_str() {
-        env.push(("CARGO_MANIFEST_DIR".into(), cargo_manifest_dir.into()));
+    fn is_unique(&self, name: &str) -> bool {
+        self.packages.iter().filter(|(_, v)| v.name == name).count() == 1
     }
-
-    env.push(("CARGO_PKG_VERSION".into(), package.version.to_string()));
-    env.push(("CARGO_PKG_VERSION_MAJOR".into(), package.version.major.to_string()));
-    env.push(("CARGO_PKG_VERSION_MINOR".into(), package.version.minor.to_string()));
-    env.push(("CARGO_PKG_VERSION_PATCH".into(), package.version.patch.to_string()));
-
-    let pre = package.version.pre.iter().map(|id| id.to_string()).format(".");
-    env.push(("CARGO_PKG_VERSION_PRE".into(), pre.to_string()));
-
-    let authors = package.authors.join(";");
-    env.push(("CARGO_PKG_AUTHORS".into(), authors));
-
-    env.push(("CARGO_PKG_NAME".into(), package.name.clone()));
-    env.push(("CARGO_PKG_DESCRIPTION".into(), package.description.clone().unwrap_or_default()));
-    //env.push(("CARGO_PKG_HOMEPAGE".into(), package.homepage.clone().unwrap_or_default()));
-    env.push(("CARGO_PKG_REPOSITORY".into(), package.repository.clone().unwrap_or_default()));
-    env.push(("CARGO_PKG_LICENSE".into(), package.license.clone().unwrap_or_default()));
-
-    let license_file =
-        package.license_file.as_ref().map(|buf| buf.display().to_string()).unwrap_or_default();
-    env.push(("CARGO_PKG_LICENSE_FILE".into(), license_file));
 }
diff --git a/crates/project_model/src/lib.rs b/crates/project_model/src/lib.rs
index 970a7e140..a5b35ed95 100644
--- a/crates/project_model/src/lib.rs
+++ b/crates/project_model/src/lib.rs
@@ -6,6 +6,7 @@ mod project_json;
 mod sysroot;
 mod workspace;
 mod rustc_cfg;
+mod build_data;
 
 use std::{
     fs::{read_dir, ReadDir},
@@ -18,9 +19,10 @@ use paths::{AbsPath, AbsPathBuf};
 use rustc_hash::FxHashSet;
 
 pub use crate::{
+    build_data::{BuildDataCollector, BuildDataResult},
     cargo_workspace::{
-        CargoConfig, CargoWorkspace, Package, PackageData, PackageDependency, Target, TargetData,
-        TargetKind,
+        CargoConfig, CargoWorkspace, Package, PackageData, PackageDependency, RustcSource, Target,
+        TargetData, TargetKind,
     },
     project_json::{ProjectJson, ProjectJsonData},
     sysroot::Sysroot,
diff --git a/crates/project_model/src/sysroot.rs b/crates/project_model/src/sysroot.rs
index ff44dae4a..3b0ff506d 100644
--- a/crates/project_model/src/sysroot.rs
+++ b/crates/project_model/src/sysroot.rs
@@ -51,11 +51,18 @@ impl Sysroot {
     pub fn discover(cargo_toml: &AbsPath) -> Result<Sysroot> {
         log::debug!("Discovering sysroot for {}", cargo_toml.display());
         let current_dir = cargo_toml.parent().unwrap();
-        let sysroot_src_dir = discover_sysroot_src_dir(current_dir)?;
+        let sysroot_dir = discover_sysroot_dir(current_dir)?;
+        let sysroot_src_dir = discover_sysroot_src_dir(&sysroot_dir, current_dir)?;
         let res = Sysroot::load(&sysroot_src_dir)?;
         Ok(res)
     }
 
+    pub fn discover_rustc(cargo_toml: &AbsPath) -> Option<AbsPathBuf> {
+        log::debug!("Discovering rustc source for {}", cargo_toml.display());
+        let current_dir = cargo_toml.parent().unwrap();
+        discover_sysroot_dir(current_dir).ok().and_then(|sysroot_dir| get_rustc_src(&sysroot_dir))
+    }
+
     pub fn load(sysroot_src_dir: &AbsPath) -> Result<Sysroot> {
         let mut sysroot = Sysroot { crates: Arena::default() };
 
@@ -110,7 +117,18 @@ impl Sysroot {
     }
 }
 
-fn discover_sysroot_src_dir(current_dir: &AbsPath) -> Result<AbsPathBuf> {
+fn discover_sysroot_dir(current_dir: &AbsPath) -> Result<AbsPathBuf> {
+    let mut rustc = Command::new(toolchain::rustc());
+    rustc.current_dir(current_dir).args(&["--print", "sysroot"]);
+    log::debug!("Discovering sysroot by {:?}", rustc);
+    let stdout = utf8_stdout(rustc)?;
+    Ok(AbsPathBuf::assert(PathBuf::from(stdout)))
+}
+
+fn discover_sysroot_src_dir(
+    sysroot_path: &AbsPathBuf,
+    current_dir: &AbsPath,
+) -> Result<AbsPathBuf> {
     if let Ok(path) = env::var("RUST_SRC_PATH") {
         let path = AbsPathBuf::try_from(path.as_str())
             .map_err(|path| format_err!("RUST_SRC_PATH must be absolute: {}", path.display()))?;
@@ -122,14 +140,6 @@ fn discover_sysroot_src_dir(current_dir: &AbsPath) -> Result<AbsPathBuf> {
         log::debug!("RUST_SRC_PATH is set, but is invalid (no core: {:?}), ignoring", core);
     }
 
-    let sysroot_path = {
-        let mut rustc = Command::new(toolchain::rustc());
-        rustc.current_dir(current_dir).args(&["--print", "sysroot"]);
-        log::debug!("Discovering sysroot by {:?}", rustc);
-        let stdout = utf8_stdout(rustc)?;
-        AbsPathBuf::assert(PathBuf::from(stdout))
-    };
-
     get_rust_src(&sysroot_path)
         .or_else(|| {
             let mut rustup = Command::new(toolchain::rustup());
@@ -149,6 +159,16 @@ try installing the Rust source the same way you installed rustc",
         })
 }
 
+fn get_rustc_src(sysroot_path: &AbsPath) -> Option<AbsPathBuf> {
+    let rustc_src = sysroot_path.join("lib/rustlib/rustc-src/rust/compiler/rustc/Cargo.toml");
+    log::debug!("Checking for rustc source code: {}", rustc_src.display());
+    if rustc_src.exists() {
+        Some(rustc_src)
+    } else {
+        None
+    }
+}
+
 fn get_rust_src(sysroot_path: &AbsPath) -> Option<AbsPathBuf> {
     // Try the new path first since the old one still exists.
     let rust_src = sysroot_path.join("lib/rustlib/src/rust");
diff --git a/crates/project_model/src/workspace.rs b/crates/project_model/src/workspace.rs
index 8e0481ae9..0220efdb4 100644
--- a/crates/project_model/src/workspace.rs
+++ b/crates/project_model/src/workspace.rs
@@ -16,8 +16,13 @@ use proc_macro_api::ProcMacroClient;
 use rustc_hash::{FxHashMap, FxHashSet};
 
 use crate::{
-    cargo_workspace, cfg_flag::CfgFlag, rustc_cfg, sysroot::SysrootCrate, utf8_stdout, CargoConfig,
-    CargoWorkspace, ProjectJson, ProjectManifest, Sysroot, TargetKind,
+    build_data::{BuildData, BuildDataMap, BuildDataResult},
+    cargo_workspace,
+    cfg_flag::CfgFlag,
+    rustc_cfg,
+    sysroot::SysrootCrate,
+    utf8_stdout, BuildDataCollector, CargoConfig, CargoWorkspace, ProjectJson, ProjectManifest,
+    Sysroot, TargetKind,
 };
 
 /// `PackageRoot` describes a package root folder.
@@ -51,6 +56,7 @@ pub enum ProjectWorkspace {
 
 impl fmt::Debug for ProjectWorkspace {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Make sure this isn't too verbose.
         match self {
             ProjectWorkspace::Cargo { cargo, sysroot, rustc, rustc_cfg } => f
                 .debug_struct("Cargo")
@@ -60,7 +66,7 @@ impl fmt::Debug for ProjectWorkspace {
                     "n_rustc_compiler_crates",
                     &rustc.as_ref().map_or(0, |rc| rc.packages().len()),
                 )
-                .field("rustc_cfg", rustc_cfg)
+                .field("n_rustc_cfg", &rustc_cfg.len())
                 .finish(),
             ProjectWorkspace::Json { project, sysroot, rustc_cfg } => {
                 let mut debug_struct = f.debug_struct("Json");
@@ -68,7 +74,7 @@ impl fmt::Debug for ProjectWorkspace {
                 if let Some(sysroot) = sysroot {
                     debug_struct.field("n_sysroot_crates", &sysroot.crates().len());
                 }
-                debug_struct.field("rustc_cfg", rustc_cfg);
+                debug_struct.field("n_rustc_cfg", &rustc_cfg.len());
                 debug_struct.finish()
             }
         }
@@ -108,6 +114,7 @@ impl ProjectWorkspace {
                             cargo_version
                         )
                     })?;
+
                 let sysroot = if config.no_sysroot {
                     Sysroot::default()
                 } else {
@@ -119,7 +126,17 @@ impl ProjectWorkspace {
                     })?
                 };
 
-                let rustc = if let Some(rustc_dir) = &config.rustc_source {
+                let rustc_dir = if let Some(rustc_source) = &config.rustc_source {
+                    use cargo_workspace::RustcSource;
+                    match rustc_source {
+                        RustcSource::Path(path) => Some(path.clone()),
+                        RustcSource::Discover => Sysroot::discover_rustc(&cargo_toml),
+                    }
+                } else {
+                    None
+                };
+
+                let rustc = if let Some(rustc_dir) = rustc_dir {
                     Some(
                         CargoWorkspace::from_cargo_metadata(&rustc_dir, config, progress)
                             .with_context(|| {
@@ -152,7 +169,7 @@ impl ProjectWorkspace {
     /// Returns the roots for the current `ProjectWorkspace`
     /// The return type contains the path and whether or not
     /// the root is a member of the current workspace
-    pub fn to_roots(&self) -> Vec<PackageRoot> {
+    pub fn to_roots(&self, build_data: Option<&BuildDataResult>) -> Vec<PackageRoot> {
         match self {
             ProjectWorkspace::Json { project, sysroot, rustc_cfg: _ } => project
                 .crates()
@@ -178,7 +195,12 @@ impl ProjectWorkspace {
                     let pkg_root = cargo[pkg].root().to_path_buf();
 
                     let mut include = vec![pkg_root.clone()];
-                    include.extend(cargo[pkg].out_dir.clone());
+                    include.extend(
+                        build_data
+                            .and_then(|it| it.get(cargo.workspace_root()))
+                            .and_then(|map| map.get(&cargo[pkg].id))
+                            .and_then(|it| it.out_dir.clone()),
+                    );
 
                     let mut exclude = vec![pkg_root.join(".git")];
                     if is_member {
@@ -218,6 +240,7 @@ impl ProjectWorkspace {
 
     pub fn to_crate_graph(
         &self,
+        build_data: Option<&BuildDataResult>,
         proc_macro_client: Option<&ProcMacroClient>,
         load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
     ) -> CrateGraph {
@@ -240,8 +263,10 @@ impl ProjectWorkspace {
                 &proc_macro_loader,
                 load,
                 cargo,
+                build_data.and_then(|it| it.get(cargo.workspace_root())),
                 sysroot,
                 rustc,
+                rustc.as_ref().zip(build_data).and_then(|(it, map)| map.get(it.workspace_root())),
             ),
         };
         if crate_graph.patch_cfg_if() {
@@ -251,6 +276,18 @@ impl ProjectWorkspace {
         }
         crate_graph
     }
+
+    pub fn collect_build_data_configs(&self, collector: &mut BuildDataCollector) {
+        match self {
+            ProjectWorkspace::Cargo { cargo, rustc, .. } => {
+                collector.add_config(&cargo.workspace_root(), cargo.build_data_config().clone());
+                if let Some(rustc) = rustc {
+                    collector.add_config(rustc.workspace_root(), rustc.build_data_config().clone());
+                }
+            }
+            _ => {}
+        }
+    }
 }
 
 fn project_json_to_crate_graph(
@@ -323,8 +360,10 @@ fn cargo_to_crate_graph(
     proc_macro_loader: &dyn Fn(&Path) -> Vec<ProcMacro>,
     load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
     cargo: &CargoWorkspace,
+    build_data_map: Option<&BuildDataMap>,
     sysroot: &Sysroot,
     rustc: &Option<CargoWorkspace>,
+    rustc_build_data_map: Option<&BuildDataMap>,
 ) -> CrateGraph {
     let _p = profile::span("cargo_to_crate_graph");
     let mut crate_graph = CrateGraph::default();
@@ -350,6 +389,7 @@ fn cargo_to_crate_graph(
                 let crate_id = add_target_crate_root(
                     &mut crate_graph,
                     &cargo[pkg],
+                    build_data_map.and_then(|it| it.get(&cargo[pkg].id)),
                     &cfg_options,
                     proc_macro_loader,
                     file_id,
@@ -426,6 +466,7 @@ fn cargo_to_crate_graph(
                     let crate_id = add_target_crate_root(
                         &mut crate_graph,
                         &rustc_workspace[pkg],
+                        rustc_build_data_map.and_then(|it| it.get(&rustc_workspace[pkg].id)),
                         &cfg_options,
                         proc_macro_loader,
                         file_id,
@@ -474,6 +515,7 @@ fn cargo_to_crate_graph(
 fn add_target_crate_root(
     crate_graph: &mut CrateGraph,
     pkg: &cargo_workspace::PackageData,
+    build_data: Option<&BuildData>,
     cfg_options: &CfgOptions,
     proc_macro_loader: &dyn Fn(&Path) -> Vec<ProcMacro>,
     file_id: FileId,
@@ -481,26 +523,27 @@ fn add_target_crate_root(
     let edition = pkg.edition;
     let cfg_options = {
         let mut opts = cfg_options.clone();
-        for feature in pkg.features.iter() {
+        for feature in pkg.active_features.iter() {
             opts.insert_key_value("feature".into(), feature.into());
         }
-        opts.extend(pkg.cfgs.iter().cloned());
+        if let Some(cfgs) = build_data.as_ref().map(|it| &it.cfgs) {
+            opts.extend(cfgs.iter().cloned());
+        }
         opts
     };
 
     let mut env = Env::default();
-    for (k, v) in &pkg.envs {
-        env.set(k, v.clone());
-    }
-    if let Some(out_dir) = &pkg.out_dir {
-        // NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!()
-        if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) {
-            env.set("OUT_DIR", out_dir);
+    if let Some(envs) = build_data.map(|it| &it.envs) {
+        for (k, v) in envs {
+            env.set(k, v.clone());
         }
     }
 
-    let proc_macro =
-        pkg.proc_macro_dylib_path.as_ref().map(|it| proc_macro_loader(&it)).unwrap_or_default();
+    let proc_macro = build_data
+        .as_ref()
+        .and_then(|it| it.proc_macro_dylib_path.as_ref())
+        .map(|it| proc_macro_loader(&it))
+        .unwrap_or_default();
 
     let display_name = CrateDisplayName::from_canonical_name(pkg.name.clone());
     let crate_id = crate_graph.add_crate_root(