5 files changed, 285 insertions, 227 deletions

diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs
index a306ce95f..4182ca156 100644
--- a/crates/ra_project_model/src/cargo_workspace.rs
+++ b/crates/ra_project_model/src/cargo_workspace.rs
@@ -9,6 +9,7 @@ use std::{
 
 use anyhow::{Context, Result};
 use cargo_metadata::{BuildScript, CargoOpt, Message, MetadataCommand, PackageId};
+use paths::{AbsPath, AbsPathBuf};
 use ra_arena::{Arena, Idx};
 use ra_db::Edition;
 use rustc_hash::FxHashMap;
@@ -20,11 +21,14 @@ use rustc_hash::FxHashMap;
 /// `CrateGraph`. `CrateGraph` is lower-level: it knows only about the crates,
 /// while this knows about `Packages` & `Targets`: purely cargo-related
 /// concepts.
-#[derive(Debug, Clone)]
+///
+/// We use absolute paths here, `cargo metadata` guarantees to always produce
+/// abs paths.
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct CargoWorkspace {
     packages: Arena<PackageData>,
     targets: Arena<TargetData>,
-    workspace_root: PathBuf,
+    workspace_root: AbsPathBuf,
 }
 
 impl ops::Index<Package> for CargoWorkspace {
@@ -41,7 +45,7 @@ impl ops::Index<Target> for CargoWorkspace {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Default, Clone, Debug, PartialEq, Eq)]
 pub struct CargoConfig {
     /// Do not activate the `default` feature.
     pub no_default_features: bool,
@@ -60,48 +64,36 @@ pub struct CargoConfig {
     pub target: Option<String>,
 }
 
-impl Default for CargoConfig {
-    fn default() -> Self {
-        CargoConfig {
-            no_default_features: false,
-            all_features: true,
-            features: Vec::new(),
-            load_out_dirs_from_check: false,
-            target: None,
-        }
-    }
-}
-
 pub type Package = Idx<PackageData>;
 
 pub type Target = Idx<TargetData>;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct PackageData {
     pub version: String,
     pub name: String,
-    pub manifest: PathBuf,
+    pub manifest: AbsPathBuf,
     pub targets: Vec<Target>,
     pub is_member: bool,
     pub dependencies: Vec<PackageDependency>,
     pub edition: Edition,
     pub features: Vec<String>,
     pub cfgs: Vec<String>,
-    pub out_dir: Option<PathBuf>,
-    pub proc_macro_dylib_path: Option<PathBuf>,
+    pub out_dir: Option<AbsPathBuf>,
+    pub proc_macro_dylib_path: Option<AbsPathBuf>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct PackageDependency {
     pub pkg: Package,
     pub name: String,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct TargetData {
     pub package: Package,
     pub name: String,
-    pub root: PathBuf,
+    pub root: AbsPathBuf,
     pub kind: TargetKind,
     pub is_proc_macro: bool,
 }
@@ -135,19 +127,19 @@ impl TargetKind {
 }
 
 impl PackageData {
-    pub fn root(&self) -> &Path {
+    pub fn root(&self) -> &AbsPath {
         self.manifest.parent().unwrap()
     }
 }
 
 impl CargoWorkspace {
     pub fn from_cargo_metadata(
-        cargo_toml: &Path,
+        cargo_toml: &AbsPath,
         cargo_features: &CargoConfig,
     ) -> Result<CargoWorkspace> {
         let mut meta = MetadataCommand::new();
         meta.cargo_path(ra_toolchain::cargo());
-        meta.manifest_path(cargo_toml);
+        meta.manifest_path(cargo_toml.to_path_buf());
         if cargo_features.all_features {
             meta.features(CargoOpt::AllFeatures);
         } else if cargo_features.no_default_features {
@@ -158,12 +150,12 @@ impl CargoWorkspace {
             meta.features(CargoOpt::SomeFeatures(cargo_features.features.clone()));
         }
         if let Some(parent) = cargo_toml.parent() {
-            meta.current_dir(parent);
+            meta.current_dir(parent.to_path_buf());
         }
         if let Some(target) = cargo_features.target.as_ref() {
             meta.other_options(vec![String::from("--filter-platform"), target.clone()]);
         }
-        let meta = meta.exec().with_context(|| {
+        let mut meta = meta.exec().with_context(|| {
             format!("Failed to run `cargo metadata --manifest-path {}`", cargo_toml.display())
         })?;
 
@@ -183,6 +175,7 @@ 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 cargo_metadata::Package { id, edition, name, manifest_path, version, .. } =
                 meta_pkg;
@@ -193,7 +186,7 @@ impl CargoWorkspace {
             let pkg = packages.alloc(PackageData {
                 name,
                 version: version.to_string(),
-                manifest: manifest_path,
+                manifest: AbsPathBuf::assert(manifest_path),
                 targets: Vec::new(),
                 is_member,
                 edition,
@@ -210,7 +203,7 @@ impl CargoWorkspace {
                 let tgt = targets.alloc(TargetData {
                     package: pkg,
                     name: meta_tgt.name,
-                    root: meta_tgt.src_path.clone(),
+                    root: AbsPathBuf::assert(meta_tgt.src_path.clone()),
                     kind: TargetKind::new(meta_tgt.kind.as_slice()),
                     is_proc_macro,
                 });
@@ -218,7 +211,7 @@ impl CargoWorkspace {
             }
         }
         let resolve = meta.resolve.expect("metadata executed with deps");
-        for node in resolve.nodes {
+        for mut node in resolve.nodes {
             let source = match pkg_by_id.get(&node.id) {
                 Some(&src) => src,
                 // FIXME: replace this and a similar branch below with `.unwrap`, once
@@ -229,6 +222,7 @@ impl CargoWorkspace {
                     continue;
                 }
             };
+            node.deps.sort_by(|a, b| a.pkg.cmp(&b.pkg));
             for dep_node in node.deps {
                 let pkg = match pkg_by_id.get(&dep_node.pkg) {
                     Some(&pkg) => pkg,
@@ -246,21 +240,22 @@ impl CargoWorkspace {
             packages[source].features.extend(node.features);
         }
 
-        Ok(CargoWorkspace { packages, targets, workspace_root: meta.workspace_root })
+        let workspace_root = AbsPathBuf::assert(meta.workspace_root);
+        Ok(CargoWorkspace { packages, targets, workspace_root: workspace_root })
     }
 
     pub fn packages<'a>(&'a self) -> impl Iterator<Item = Package> + ExactSizeIterator + 'a {
         self.packages.iter().map(|(id, _pkg)| id)
     }
 
-    pub fn target_by_root(&self, root: &Path) -> Option<Target> {
+    pub fn target_by_root(&self, root: &AbsPath) -> Option<Target> {
         self.packages()
-            .filter_map(|pkg| self[pkg].targets.iter().find(|&&it| self[it].root == root))
+            .filter_map(|pkg| self[pkg].targets.iter().find(|&&it| &self[it].root == root))
             .next()
             .copied()
     }
 
-    pub fn workspace_root(&self) -> &Path {
+    pub fn workspace_root(&self) -> &AbsPath {
         &self.workspace_root
     }
 
@@ -279,8 +274,8 @@ impl CargoWorkspace {
 
 #[derive(Debug, Clone, Default)]
 pub struct ExternResources {
-    out_dirs: FxHashMap<PackageId, PathBuf>,
-    proc_dylib_paths: FxHashMap<PackageId, PathBuf>,
+    out_dirs: FxHashMap<PackageId, AbsPathBuf>,
+    proc_dylib_paths: FxHashMap<PackageId, AbsPathBuf>,
     cfgs: FxHashMap<PackageId, Vec<String>>,
 }
 
@@ -308,8 +303,13 @@ pub fn load_extern_resources(
         if let Ok(message) = message {
             match message {
                 Message::BuildScriptExecuted(BuildScript { package_id, out_dir, cfgs, .. }) => {
-                    res.out_dirs.insert(package_id.clone(), out_dir);
-                    res.cfgs.insert(package_id, cfgs);
+                    // 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, cfgs);
+                    }
                 }
                 Message::CompilerArtifact(message) => {
                     if message.target.kind.contains(&"proc-macro".to_string()) {
@@ -317,7 +317,8 @@ pub fn load_extern_resources(
                         // Skip rmeta file
                         if let Some(filename) = message.filenames.iter().find(|name| is_dylib(name))
                         {
-                            res.proc_dylib_paths.insert(package_id, filename.clone());
+                            let filename = AbsPathBuf::assert(filename.clone());
+                            res.proc_dylib_paths.insert(package_id, filename);
                         }
                     }
                 }
diff --git a/crates/ra_project_model/src/json_project.rs b/crates/ra_project_model/src/json_project.rs
deleted file mode 100644
index b030c8a6a..000000000
--- a/crates/ra_project_model/src/json_project.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-//! FIXME: write short doc here
-
-use std::path::PathBuf;
-
-use rustc_hash::{FxHashMap, FxHashSet};
-use serde::Deserialize;
-
-/// A root points to the directory which contains Rust crates. rust-analyzer watches all files in
-/// all roots. Roots might be nested.
-#[derive(Clone, Debug, Deserialize)]
-#[serde(transparent)]
-pub struct Root {
-    pub(crate) path: PathBuf,
-}
-
-/// A crate points to the root module of a crate and lists the dependencies of the crate. This is
-/// useful in creating the crate graph.
-#[derive(Clone, Debug, Deserialize)]
-pub struct Crate {
-    pub(crate) root_module: PathBuf,
-    pub(crate) edition: Edition,
-    pub(crate) deps: Vec<Dep>,
-    pub(crate) atom_cfgs: FxHashSet<String>,
-    pub(crate) key_value_cfgs: FxHashMap<String, String>,
-    pub(crate) out_dir: Option<PathBuf>,
-    pub(crate) proc_macro_dylib_path: Option<PathBuf>,
-}
-
-#[derive(Clone, Copy, Debug, Deserialize)]
-#[serde(rename = "edition")]
-pub enum Edition {
-    #[serde(rename = "2015")]
-    Edition2015,
-    #[serde(rename = "2018")]
-    Edition2018,
-}
-
-/// Identifies a crate by position in the crates array.
-#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd)]
-#[serde(transparent)]
-pub struct CrateId(pub usize);
-
-/// A dependency of a crate, identified by its id in the crates array and name.
-#[derive(Clone, Debug, Deserialize)]
-pub struct Dep {
-    #[serde(rename = "crate")]
-    pub(crate) krate: CrateId,
-    pub(crate) name: String,
-}
-
-/// Roots and crates that compose this Rust project.
-#[derive(Clone, Debug, Deserialize)]
-pub struct JsonProject {
-    pub(crate) roots: Vec<Root>,
-    pub(crate) crates: Vec<Crate>,
-}
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index a2e9f65ef..b9c5424bf 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -1,35 +1,35 @@
 //! FIXME: write short doc here
 
 mod cargo_workspace;
-mod json_project;
+mod project_json;
 mod sysroot;
 
 use std::{
-    fs::{read_dir, File, ReadDir},
-    io::{self, BufReader},
-    path::{Path, PathBuf},
+    fs::{self, read_dir, ReadDir},
+    io,
+    path::Path,
     process::{Command, Output},
 };
 
 use anyhow::{bail, Context, Result};
+use paths::{AbsPath, AbsPathBuf};
 use ra_cfg::CfgOptions;
-use ra_db::{CrateGraph, CrateName, Edition, Env, ExternSource, ExternSourceId, FileId};
-use rustc_hash::FxHashMap;
-use serde_json::from_reader;
+use ra_db::{CrateGraph, CrateId, CrateName, Edition, Env, FileId};
+use rustc_hash::{FxHashMap, FxHashSet};
 
 pub use crate::{
     cargo_workspace::{CargoConfig, CargoWorkspace, Package, Target, TargetKind},
-    json_project::JsonProject,
+    project_json::{ProjectJson, ProjectJsonData},
     sysroot::Sysroot,
 };
 pub use ra_proc_macro::ProcMacroClient;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub enum ProjectWorkspace {
     /// Project workspace was discovered by running `cargo metadata` and `rustc --print sysroot`.
     Cargo { cargo: CargoWorkspace, sysroot: Sysroot },
     /// Project workspace was manually specified using a `rust-project.json` file.
-    Json { project: JsonProject },
+    Json { project: ProjectJson },
 }
 
 /// `PackageRoot` describes a package root folder.
@@ -38,44 +38,48 @@ pub enum ProjectWorkspace {
 #[derive(Debug, Clone)]
 pub struct PackageRoot {
     /// Path to the root folder
-    path: PathBuf,
+    path: AbsPathBuf,
     /// Is a member of the current workspace
     is_member: bool,
+    out_dir: Option<AbsPathBuf>,
 }
 impl PackageRoot {
-    pub fn new_member(path: PathBuf) -> PackageRoot {
-        Self { path, is_member: true }
+    pub fn new_member(path: AbsPathBuf) -> PackageRoot {
+        Self { path, is_member: true, out_dir: None }
     }
-    pub fn new_non_member(path: PathBuf) -> PackageRoot {
-        Self { path, is_member: false }
+    pub fn new_non_member(path: AbsPathBuf) -> PackageRoot {
+        Self { path, is_member: false, out_dir: None }
     }
-    pub fn path(&self) -> &Path {
+    pub fn path(&self) -> &AbsPath {
         &self.path
     }
+    pub fn out_dir(&self) -> Option<&AbsPath> {
+        self.out_dir.as_deref()
+    }
     pub fn is_member(&self) -> bool {
         self.is_member
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum ProjectRoot {
-    ProjectJson(PathBuf),
-    CargoToml(PathBuf),
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub enum ProjectManifest {
+    ProjectJson(AbsPathBuf),
+    CargoToml(AbsPathBuf),
 }
 
-impl ProjectRoot {
-    pub fn from_manifest_file(path: PathBuf) -> Result<ProjectRoot> {
+impl ProjectManifest {
+    pub fn from_manifest_file(path: AbsPathBuf) -> Result<ProjectManifest> {
         if path.ends_with("rust-project.json") {
-            return Ok(ProjectRoot::ProjectJson(path));
+            return Ok(ProjectManifest::ProjectJson(path));
         }
         if path.ends_with("Cargo.toml") {
-            return Ok(ProjectRoot::CargoToml(path));
+            return Ok(ProjectManifest::CargoToml(path));
         }
         bail!("project root must point to Cargo.toml or rust-project.json: {}", path.display())
     }
 
-    pub fn discover_single(path: &Path) -> Result<ProjectRoot> {
-        let mut candidates = ProjectRoot::discover(path)?;
+    pub fn discover_single(path: &AbsPath) -> Result<ProjectManifest> {
+        let mut candidates = ProjectManifest::discover(path)?;
         let res = match candidates.pop() {
             None => bail!("no projects"),
             Some(it) => it,
@@ -87,23 +91,23 @@ impl ProjectRoot {
         Ok(res)
     }
 
-    pub fn discover(path: &Path) -> io::Result<Vec<ProjectRoot>> {
+    pub fn discover(path: &AbsPath) -> io::Result<Vec<ProjectManifest>> {
         if let Some(project_json) = find_in_parent_dirs(path, "rust-project.json") {
-            return Ok(vec![ProjectRoot::ProjectJson(project_json)]);
+            return Ok(vec![ProjectManifest::ProjectJson(project_json)]);
         }
         return find_cargo_toml(path)
-            .map(|paths| paths.into_iter().map(ProjectRoot::CargoToml).collect());
+            .map(|paths| paths.into_iter().map(ProjectManifest::CargoToml).collect());
 
-        fn find_cargo_toml(path: &Path) -> io::Result<Vec<PathBuf>> {
+        fn find_cargo_toml(path: &AbsPath) -> io::Result<Vec<AbsPathBuf>> {
             match find_in_parent_dirs(path, "Cargo.toml") {
                 Some(it) => Ok(vec![it]),
                 None => Ok(find_cargo_toml_in_child_dir(read_dir(path)?)),
             }
         }
 
-        fn find_in_parent_dirs(path: &Path, target_file_name: &str) -> Option<PathBuf> {
+        fn find_in_parent_dirs(path: &AbsPath, target_file_name: &str) -> Option<AbsPathBuf> {
             if path.ends_with(target_file_name) {
-                return Some(path.to_owned());
+                return Some(path.to_path_buf());
             }
 
             let mut curr = Some(path);
@@ -119,37 +123,50 @@ impl ProjectRoot {
             None
         }
 
-        fn find_cargo_toml_in_child_dir(entities: ReadDir) -> Vec<PathBuf> {
+        fn find_cargo_toml_in_child_dir(entities: ReadDir) -> Vec<AbsPathBuf> {
             // Only one level down to avoid cycles the easy way and stop a runaway scan with large projects
             entities
                 .filter_map(Result::ok)
                 .map(|it| it.path().join("Cargo.toml"))
                 .filter(|it| it.exists())
+                .map(AbsPathBuf::assert)
                 .collect()
         }
     }
+
+    pub fn discover_all(paths: &[impl AsRef<AbsPath>]) -> Vec<ProjectManifest> {
+        let mut res = paths
+            .iter()
+            .filter_map(|it| ProjectManifest::discover(it.as_ref()).ok())
+            .flatten()
+            .collect::<FxHashSet<_>>()
+            .into_iter()
+            .collect::<Vec<_>>();
+        res.sort();
+        res
+    }
 }
 
 impl ProjectWorkspace {
     pub fn load(
-        root: ProjectRoot,
-        cargo_features: &CargoConfig,
+        manifest: ProjectManifest,
+        cargo_config: &CargoConfig,
         with_sysroot: bool,
     ) -> Result<ProjectWorkspace> {
-        let res = match root {
-            ProjectRoot::ProjectJson(project_json) => {
-                let file = File::open(&project_json).with_context(|| {
-                    format!("Failed to open json file {}", project_json.display())
+        let res = match manifest {
+            ProjectManifest::ProjectJson(project_json) => {
+                let file = fs::read_to_string(&project_json).with_context(|| {
+                    format!("Failed to read json file {}", project_json.display())
                 })?;
-                let reader = BufReader::new(file);
-                ProjectWorkspace::Json {
-                    project: from_reader(reader).with_context(|| {
-                        format!("Failed to deserialize json file {}", project_json.display())
-                    })?,
-                }
+                let data = serde_json::from_str(&file).with_context(|| {
+                    format!("Failed to deserialize json file {}", project_json.display())
+                })?;
+                let project_location = project_json.parent().unwrap().to_path_buf();
+                let project = ProjectJson::new(&project_location, data);
+                ProjectWorkspace::Json { project }
             }
-            ProjectRoot::CargoToml(cargo_toml) => {
-                let cargo = CargoWorkspace::from_cargo_metadata(&cargo_toml, cargo_features)
+            ProjectManifest::CargoToml(cargo_toml) => {
+                let cargo = CargoWorkspace::from_cargo_metadata(&cargo_toml, cargo_config)
                     .with_context(|| {
                         format!(
                             "Failed to read Cargo metadata from Cargo.toml file {}",
@@ -186,6 +203,7 @@ impl ProjectWorkspace {
                 .map(|pkg| PackageRoot {
                     path: cargo[pkg].root().to_path_buf(),
                     is_member: cargo[pkg].is_member,
+                    out_dir: cargo[pkg].out_dir.clone(),
                 })
                 .chain(sysroot.crates().map(|krate| {
                     PackageRoot::new_non_member(sysroot[krate].root_dir().to_path_buf())
@@ -194,18 +212,7 @@ impl ProjectWorkspace {
         }
     }
 
-    pub fn out_dirs(&self) -> Vec<PathBuf> {
-        match self {
-            ProjectWorkspace::Json { project } => {
-                project.crates.iter().filter_map(|krate| krate.out_dir.as_ref()).cloned().collect()
-            }
-            ProjectWorkspace::Cargo { cargo, sysroot: _ } => {
-                cargo.packages().filter_map(|pkg| cargo[pkg].out_dir.as_ref()).cloned().collect()
-            }
-        }
-    }
-
-    pub fn proc_macro_dylib_paths(&self) -> Vec<PathBuf> {
+    pub fn proc_macro_dylib_paths(&self) -> Vec<AbsPathBuf> {
         match self {
             ProjectWorkspace::Json { project } => project
                 .crates
@@ -223,7 +230,7 @@ impl ProjectWorkspace {
 
     pub fn n_packages(&self) -> usize {
         match self {
-            ProjectWorkspace::Json { project } => project.crates.len(),
+            ProjectWorkspace::Json { project, .. } => project.crates.len(),
             ProjectWorkspace::Cargo { cargo, sysroot } => {
                 cargo.packages().len() + sysroot.crates().len()
             }
@@ -232,61 +239,51 @@ impl ProjectWorkspace {
 
     pub fn to_crate_graph(
         &self,
-        default_cfg_options: &CfgOptions,
-        extern_source_roots: &FxHashMap<PathBuf, ExternSourceId>,
+        target: Option<&str>,
         proc_macro_client: &ProcMacroClient,
-        load: &mut dyn FnMut(&Path) -> Option<FileId>,
+        load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
     ) -> CrateGraph {
         let mut crate_graph = CrateGraph::default();
         match self {
             ProjectWorkspace::Json { project } => {
+                let mut target_cfg_map = FxHashMap::<Option<&str>, CfgOptions>::default();
                 let crates: FxHashMap<_, _> = project
                     .crates
                     .iter()
                     .enumerate()
                     .filter_map(|(seq_index, krate)| {
-                        let file_id = load(&krate.root_module)?;
-                        let edition = match krate.edition {
-                            json_project::Edition::Edition2015 => Edition::Edition2015,
-                            json_project::Edition::Edition2018 => Edition::Edition2018,
-                        };
-                        let cfg_options = {
-                            let mut opts = default_cfg_options.clone();
-                            for name in &krate.atom_cfgs {
-                                opts.insert_atom(name.into());
-                            }
-                            for (key, value) in &krate.key_value_cfgs {
-                                opts.insert_key_value(key.into(), value.into());
-                            }
-                            opts
-                        };
+                        let file_path = &krate.root_module;
+                        let file_id = load(&file_path)?;
 
                         let mut env = Env::default();
-                        let mut extern_source = ExternSource::default();
                         if let Some(out_dir) = &krate.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(&extern_source_id) = extern_source_roots.get(out_dir) {
-                                extern_source.set_extern_path(&out_dir, extern_source_id);
-                            }
                         }
                         let proc_macro = krate
                             .proc_macro_dylib_path
                             .clone()
                             .map(|it| proc_macro_client.by_dylib_path(&it));
+
+                        let target = krate.target.as_deref().or(target);
+                        let target_cfgs = target_cfg_map
+                            .entry(target.clone())
+                            .or_insert_with(|| get_rustc_cfg_options(target.as_deref()));
+                        let mut cfg_options = krate.cfg.clone();
+                        cfg_options.append(target_cfgs);
+
                         // FIXME: No crate name in json definition such that we cannot add OUT_DIR to env
                         Some((
-                            json_project::CrateId(seq_index),
+                            CrateId(seq_index as u32),
                             crate_graph.add_crate_root(
                                 file_id,
-                                edition,
+                                krate.edition,
                                 // FIXME json definitions can store the crate name
                                 None,
                                 cfg_options,
                                 env,
-                                extern_source,
                                 proc_macro.unwrap_or_default(),
                             ),
                         ))
@@ -295,15 +292,12 @@ impl ProjectWorkspace {
 
                 for (id, krate) in project.crates.iter().enumerate() {
                     for dep in &krate.deps {
-                        let from_crate_id = json_project::CrateId(id);
-                        let to_crate_id = dep.krate;
+                        let from_crate_id = CrateId(id as u32);
+                        let to_crate_id = dep.crate_id;
                         if let (Some(&from), Some(&to)) =
                             (crates.get(&from_crate_id), crates.get(&to_crate_id))
                         {
-                            if crate_graph
-                                .add_dep(from, CrateName::new(&dep.name).unwrap(), to)
-                                .is_err()
-                            {
+                            if crate_graph.add_dep(from, dep.name.clone(), to).is_err() {
                                 log::error!(
                                     "cyclic dependency {:?} -> {:?}",
                                     from_crate_id,
@@ -315,31 +309,22 @@ impl ProjectWorkspace {
                 }
             }
             ProjectWorkspace::Cargo { cargo, sysroot } => {
+                let mut cfg_options = get_rustc_cfg_options(target);
+
                 let sysroot_crates: FxHashMap<_, _> = sysroot
                     .crates()
                     .filter_map(|krate| {
                         let file_id = load(&sysroot[krate].root)?;
 
-                        // Crates from sysroot have `cfg(test)` disabled
-                        let cfg_options = {
-                            let mut opts = default_cfg_options.clone();
-                            opts.remove_atom("test");
-                            opts
-                        };
-
                         let env = Env::default();
-                        let extern_source = ExternSource::default();
                         let proc_macro = vec![];
-                        let crate_name = CrateName::new(&sysroot[krate].name)
-                            .expect("Sysroot crate names should not contain dashes");
-
+                        let name = sysroot[krate].name.clone();
                         let crate_id = crate_graph.add_crate_root(
                             file_id,
                             Edition::Edition2018,
-                            Some(crate_name),
-                            cfg_options,
+                            Some(name),
+                            cfg_options.clone(),
                             env,
-                            extern_source,
                             proc_macro,
                         );
                         Some((krate, crate_id))
@@ -368,6 +353,10 @@ impl ProjectWorkspace {
 
                 let mut pkg_to_lib_crate = FxHashMap::default();
                 let mut pkg_crates = FxHashMap::default();
+
+                // Add test cfg for non-sysroot crates
+                cfg_options.insert_atom("test".into());
+
                 // Next, create crates for each package, target pair
                 for pkg in cargo.packages() {
                     let mut lib_tgt = None;
@@ -376,7 +365,7 @@ impl ProjectWorkspace {
                         if let Some(file_id) = load(root) {
                             let edition = cargo[pkg].edition;
                             let cfg_options = {
-                                let mut opts = default_cfg_options.clone();
+                                let mut opts = cfg_options.clone();
                                 for feature in cargo[pkg].features.iter() {
                                     opts.insert_key_value("feature".into(), feature.into());
                                 }
@@ -392,15 +381,11 @@ impl ProjectWorkspace {
                                 opts
                             };
                             let mut env = Env::default();
-                            let mut extern_source = ExternSource::default();
                             if let Some(out_dir) = &cargo[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(&extern_source_id) = extern_source_roots.get(out_dir) {
-                                    extern_source.set_extern_path(&out_dir, extern_source_id);
-                                }
                             }
                             let proc_macro = cargo[pkg]
                                 .proc_macro_dylib_path
@@ -411,10 +396,9 @@ impl ProjectWorkspace {
                             let crate_id = crate_graph.add_crate_root(
                                 file_id,
                                 edition,
-                                Some(CrateName::normalize_dashes(&cargo[pkg].name)),
+                                Some(cargo[pkg].name.clone()),
                                 cfg_options,
                                 env,
-                                extern_source,
                                 proc_macro.clone(),
                             );
                             if cargo[tgt].kind == TargetKind::Lib {
@@ -520,20 +504,20 @@ impl ProjectWorkspace {
         crate_graph
     }
 
-    pub fn workspace_root_for(&self, path: &Path) -> Option<&Path> {
+    pub fn workspace_root_for(&self, path: &Path) -> Option<&AbsPath> {
         match self {
             ProjectWorkspace::Cargo { cargo, .. } => {
                 Some(cargo.workspace_root()).filter(|root| path.starts_with(root))
             }
-            ProjectWorkspace::Json { project: JsonProject { roots, .. } } => roots
+            ProjectWorkspace::Json { project: ProjectJson { roots, .. }, .. } => roots
                 .iter()
                 .find(|root| path.starts_with(&root.path))
-                .map(|root| root.path.as_ref()),
+                .map(|root| root.path.as_path()),
         }
     }
 }
 
-pub fn get_rustc_cfg_options(target: Option<&String>) -> CfgOptions {
+fn get_rustc_cfg_options(target: Option<&str>) -> CfgOptions {
     let mut cfg_options = CfgOptions::default();
 
     // Some nightly-only cfgs, which are required for stdlib
@@ -551,7 +535,7 @@ pub fn get_rustc_cfg_options(target: Option<&String>) -> CfgOptions {
         let mut cmd = Command::new(ra_toolchain::rustc());
         cmd.args(&["--print", "cfg", "-O"]);
         if let Some(target) = target {
-            cmd.args(&["--target", target.as_str()]);
+            cmd.args(&["--target", target]);
         }
         let output = output(cmd)?;
         Ok(String::from_utf8(output.stdout)?)
@@ -573,6 +557,8 @@ pub fn get_rustc_cfg_options(target: Option<&String>) -> CfgOptions {
         Err(e) => log::error!("failed to get rustc cfgs: {:#}", e),
     }
 
+    cfg_options.insert_atom("debug_assertions".into());
+
     cfg_options
 }
 
diff --git a/crates/ra_project_model/src/project_json.rs b/crates/ra_project_model/src/project_json.rs
new file mode 100644
index 000000000..b96227949
--- /dev/null
+++ b/crates/ra_project_model/src/project_json.rs
@@ -0,0 +1,129 @@
+//! FIXME: write short doc here
+
+use std::path::PathBuf;
+
+use paths::{AbsPath, AbsPathBuf};
+use ra_cfg::CfgOptions;
+use ra_db::{CrateId, CrateName, Dependency, Edition};
+use rustc_hash::FxHashSet;
+use serde::{de, Deserialize};
+use stdx::split_delim;
+
+/// Roots and crates that compose this Rust project.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ProjectJson {
+    pub(crate) roots: Vec<Root>,
+    pub(crate) crates: Vec<Crate>,
+}
+
+/// A root points to the directory which contains Rust crates. rust-analyzer watches all files in
+/// all roots. Roots might be nested.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Root {
+    pub(crate) path: AbsPathBuf,
+}
+
+/// A crate points to the root module of a crate and lists the dependencies of the crate. This is
+/// useful in creating the crate graph.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Crate {
+    pub(crate) root_module: AbsPathBuf,
+    pub(crate) edition: Edition,
+    pub(crate) deps: Vec<Dependency>,
+    pub(crate) cfg: CfgOptions,
+    pub(crate) target: Option<String>,
+    pub(crate) out_dir: Option<AbsPathBuf>,
+    pub(crate) proc_macro_dylib_path: Option<AbsPathBuf>,
+}
+
+impl ProjectJson {
+    pub fn new(base: &AbsPath, data: ProjectJsonData) -> ProjectJson {
+        ProjectJson {
+            roots: data.roots.into_iter().map(|path| Root { path: base.join(path) }).collect(),
+            crates: data
+                .crates
+                .into_iter()
+                .map(|crate_data| Crate {
+                    root_module: base.join(crate_data.root_module),
+                    edition: crate_data.edition.into(),
+                    deps: crate_data
+                        .deps
+                        .into_iter()
+                        .map(|dep_data| Dependency {
+                            crate_id: CrateId(dep_data.krate as u32),
+                            name: dep_data.name,
+                        })
+                        .collect::<Vec<_>>(),
+                    cfg: {
+                        let mut cfg = CfgOptions::default();
+                        for entry in &crate_data.cfg {
+                            match split_delim(entry, '=') {
+                                Some((key, value)) => {
+                                    cfg.insert_key_value(key.into(), value.into());
+                                }
+                                None => cfg.insert_atom(entry.into()),
+                            }
+                        }
+                        cfg
+                    },
+                    target: crate_data.target,
+                    out_dir: crate_data.out_dir.map(|it| base.join(it)),
+                    proc_macro_dylib_path: crate_data.proc_macro_dylib_path.map(|it| base.join(it)),
+                })
+                .collect::<Vec<_>>(),
+        }
+    }
+}
+
+#[derive(Deserialize)]
+pub struct ProjectJsonData {
+    roots: Vec<PathBuf>,
+    crates: Vec<CrateData>,
+}
+
+#[derive(Deserialize)]
+struct CrateData {
+    root_module: PathBuf,
+    edition: EditionData,
+    deps: Vec<DepData>,
+    #[serde(default)]
+    cfg: FxHashSet<String>,
+    target: Option<String>,
+    out_dir: Option<PathBuf>,
+    proc_macro_dylib_path: Option<PathBuf>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename = "edition")]
+enum EditionData {
+    #[serde(rename = "2015")]
+    Edition2015,
+    #[serde(rename = "2018")]
+    Edition2018,
+}
+
+impl From<EditionData> for Edition {
+    fn from(data: EditionData) -> Self {
+        match data {
+            EditionData::Edition2015 => Edition::Edition2015,
+            EditionData::Edition2018 => Edition::Edition2018,
+        }
+    }
+}
+
+#[derive(Deserialize)]
+struct DepData {
+    /// Identifies a crate by position in the crates array.
+    #[serde(rename = "crate")]
+    krate: usize,
+    #[serde(deserialize_with = "deserialize_crate_name")]
+    name: CrateName,
+}
+
+fn deserialize_crate_name<'de, D>(de: D) -> Result<CrateName, D::Error>
+where
+    D: de::Deserializer<'de>,
+{
+    let name = String::deserialize(de)?;
+    CrateName::new(&name).map_err(|err| de::Error::custom(format!("invalid crate name: {:?}", err)))
+}
diff --git a/crates/ra_project_model/src/sysroot.rs b/crates/ra_project_model/src/sysroot.rs
index a8a196e64..68d134da4 100644
--- a/crates/ra_project_model/src/sysroot.rs
+++ b/crates/ra_project_model/src/sysroot.rs
@@ -1,27 +1,24 @@
 //! FIXME: write short doc here
 
-use std::{
-    env, ops,
-    path::{Path, PathBuf},
-    process::Command,
-};
+use std::{convert::TryFrom, env, ops, path::Path, process::Command};
 
-use anyhow::{bail, Result};
+use anyhow::{bail, format_err, Result};
+use paths::{AbsPath, AbsPathBuf};
 use ra_arena::{Arena, Idx};
 
 use crate::output;
 
-#[derive(Default, Debug, Clone)]
+#[derive(Default, Debug, Clone, Eq, PartialEq)]
 pub struct Sysroot {
     crates: Arena<SysrootCrateData>,
 }
 
 pub type SysrootCrate = Idx<SysrootCrateData>;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct SysrootCrateData {
     pub name: String,
-    pub root: PathBuf,
+    pub root: AbsPathBuf,
     pub deps: Vec<SysrootCrate>,
 }
 
@@ -53,7 +50,7 @@ impl Sysroot {
         self.crates.iter().map(|(id, _data)| id)
     }
 
-    pub fn discover(cargo_toml: &Path) -> Result<Sysroot> {
+    pub fn discover(cargo_toml: &AbsPath) -> Result<Sysroot> {
         let src = get_or_install_rust_src(cargo_toml)?;
         let mut sysroot = Sysroot { crates: Arena::default() };
         for name in SYSROOT_CRATES.trim().lines() {
@@ -86,16 +83,18 @@ impl Sysroot {
     }
 }
 
-fn get_or_install_rust_src(cargo_toml: &Path) -> Result<PathBuf> {
+fn get_or_install_rust_src(cargo_toml: &AbsPath) -> Result<AbsPathBuf> {
     if let Ok(path) = env::var("RUST_SRC_PATH") {
-        return Ok(path.into());
+        let path = AbsPathBuf::try_from(path.as_str())
+            .map_err(|path| format_err!("RUST_SRC_PATH must be absolute: {}", path.display()))?;
+        return Ok(path);
     }
     let current_dir = cargo_toml.parent().unwrap();
     let mut rustc = Command::new(ra_toolchain::rustc());
     rustc.current_dir(current_dir).args(&["--print", "sysroot"]);
     let rustc_output = output(rustc)?;
     let stdout = String::from_utf8(rustc_output.stdout)?;
-    let sysroot_path = Path::new(stdout.trim());
+    let sysroot_path = AbsPath::assert(Path::new(stdout.trim()));
     let src_path = sysroot_path.join("lib/rustlib/src/rust/src");
 
     if !src_path.exists() {
@@ -116,7 +115,7 @@ fn get_or_install_rust_src(cargo_toml: &Path) -> Result<PathBuf> {
 }
 
 impl SysrootCrateData {
-    pub fn root_dir(&self) -> &Path {
+    pub fn root_dir(&self) -> &AbsPath {
         self.root.parent().unwrap()
     }
 }
@@ -127,7 +126,6 @@ core
 alloc
 collections
 libc
-panic_unwind
 proc_macro
 rustc_unicode
 std_unicode