Merge #767

767: Extract project model to separate crate r=matklad a=flodiebold

I'm looking into creating a separate crate that would allow getting a HIR db for a project for 'batch' analyses, and this seems to be an obvious first step. We'd probably want to change the error handling to not rely on failure, though, right?

Co-authored-by: Florian Diebold <[email protected]>

Author: bors[bot]

Cargo.lock

@@ -91,6 +91,7 @@ impl CrateGraph {
         assert!(prev.is_none());
         crate_id
     }
+
     pub fn add_dep(
         &mut self,
         from: CrateId,
@@ -102,22 +103,40 @@ impl CrateGraph {
         }
         Ok(self.arena.get_mut(&from).unwrap().add_dep(name, to))
     }
+
     pub fn is_empty(&self) -> bool {
         self.arena.is_empty()
     }
+
     pub fn crate_root(&self, crate_id: CrateId) -> FileId {
         self.arena[&crate_id].file_id
     }
+
     pub fn crate_id_for_crate_root(&self, file_id: FileId) -> Option<CrateId> {
         let (&crate_id, _) = self.arena.iter().find(|(_crate_id, data)| data.file_id == file_id)?;
         Some(crate_id)
     }
+
     pub fn dependencies<'a>(
         &'a self,
         crate_id: CrateId,
     ) -> impl Iterator<Item = &'a Dependency> + 'a {
         self.arena[&crate_id].dependencies.iter()
     }
+
+    /// Extends this crate graph by adding a complete disjoint second crate
+    /// graph.
+    pub fn extend(&mut self, other: CrateGraph) {
+        let start = self.arena.len() as u32;
+        self.arena.extend(other.arena.into_iter().map(|(id, mut data)| {
+            let new_id = CrateId(id.0 + start);
+            for dep in &mut data.dependencies {
+                dep.crate_id = CrateId(dep.crate_id.0 + start);
+            }
+            (new_id, data)
+        }));
+    }
+
     fn dfs_find(&self, target: CrateId, from: CrateId, visited: &mut FxHashSet<CrateId>) -> bool {
         if !visited.insert(from) {
             return false;

crates/ra_db/src/input.rs

@@ -19,7 +19,6 @@ url_serde = "0.2.0"
 lsp-types = "0.55.0"
 walkdir = "2.2.7"
 im = "12.0.0"
-cargo_metadata = "0.7.0"
 rustc-hash = "1.0"
 parking_lot = "0.7.0"
 
@@ -30,6 +29,7 @@ ra_ide_api = { path = "../ra_ide_api" }
 ra_arena = { path = "../ra_arena" }
 gen_lsp_server = { path = "../gen_lsp_server" }
 ra_vfs = { path = "../ra_vfs" }
+ra_project_model = { path = "../ra_project_model" }
 
 [dev-dependencies]
 tempfile = "3"

crates/ra_lsp_server/Cargo.toml

@@ -1,34 +1,13 @@
-mod cargo_workspace;
-mod sysroot;
+use std::path::PathBuf;
 
-use std::path::{Path, PathBuf};
-
-use failure::bail;
 use thread_worker::{WorkerHandle, Worker};
 
 use crate::Result;
 
-pub use crate::project_model::{
-    cargo_workspace::{CargoWorkspace, Package, Target, TargetKind},
-    sysroot::Sysroot,
+pub use ra_project_model::{
+    ProjectWorkspace, CargoWorkspace, Package, Target, TargetKind, Sysroot,
 };
 
-#[derive(Debug, Clone)]
-pub struct ProjectWorkspace {
-    pub(crate) cargo: CargoWorkspace,
-    pub(crate) sysroot: Sysroot,
-}
-
-impl ProjectWorkspace {
-    pub fn discover(path: &Path) -> Result<ProjectWorkspace> {
-        let cargo_toml = find_cargo_toml(path)?;
-        let cargo = CargoWorkspace::from_cargo_metadata(&cargo_toml)?;
-        let sysroot = Sysroot::discover(&cargo_toml)?;
-        let res = ProjectWorkspace { cargo, sysroot };
-        Ok(res)
-    }
-}
-
 pub fn workspace_loader() -> (Worker<PathBuf, Result<ProjectWorkspace>>, WorkerHandle) {
     thread_worker::spawn::<PathBuf, Result<ProjectWorkspace>, _>(
         "workspace loader",
@@ -42,18 +21,3 @@ pub fn workspace_loader() -> (Worker<PathBuf, Result<ProjectWorkspace>>, WorkerH
         },
     )
 }
-
-fn find_cargo_toml(path: &Path) -> Result<PathBuf> {
-    if path.ends_with("Cargo.toml") {
-        return Ok(path.to_path_buf());
-    }
-    let mut curr = Some(path);
-    while let Some(path) = curr {
-        let candidate = path.join("Cargo.toml");
-        if candidate.exists() {
-            return Ok(candidate);
-        }
-        curr = path.parent();
-    }
-    bail!("can't find Cargo.toml at {}", path.display())
-}

crates/ra_lsp_server/src/project_model.rs

@@ -9,13 +9,12 @@ use ra_ide_api::{
     SourceRootId
 };
 use ra_vfs::{Vfs, VfsChange, VfsFile, VfsRoot};
-use rustc_hash::FxHashMap;
 use relative_path::RelativePathBuf;
 use parking_lot::RwLock;
 use failure::format_err;
 
 use crate::{
-    project_model::{ProjectWorkspace, TargetKind},
+    project_model::ProjectWorkspace,
     Result,
 };
 
@@ -57,88 +56,14 @@ impl ServerWorldState {
             change.add_root(SourceRootId(r.0.into()), is_local);
         }
 
+        // Create crate graph from all the workspaces
         let mut crate_graph = CrateGraph::default();
+        let mut load = |path: &std::path::Path| {
+            let vfs_file = vfs.load(path);
+            vfs_file.map(|f| FileId(f.0.into()))
+        };
         for ws in workspaces.iter() {
-            // First, load std
-            let mut sysroot_crates = FxHashMap::default();
-            for krate in ws.sysroot.crates() {
-                if let Some(file_id) = vfs.load(krate.root(&ws.sysroot)) {
-                    let file_id = FileId(file_id.0.into());
-                    sysroot_crates.insert(krate, crate_graph.add_crate_root(file_id));
-                }
-            }
-            for from in ws.sysroot.crates() {
-                for to in from.deps(&ws.sysroot) {
-                    let name = to.name(&ws.sysroot);
-                    if let (Some(&from), Some(&to)) =
-                        (sysroot_crates.get(&from), sysroot_crates.get(&to))
-                    {
-                        if let Err(_) = crate_graph.add_dep(from, name.clone(), to) {
-                            log::error!("cyclic dependency between sysroot crates")
-                        }
-                    }
-                }
-            }
-
-            let libstd = ws.sysroot.std().and_then(|it| sysroot_crates.get(&it).map(|&it| it));
-
-            let mut pkg_to_lib_crate = FxHashMap::default();
-            let mut pkg_crates = FxHashMap::default();
-            // Next, create crates for each package, target pair
-            for pkg in ws.cargo.packages() {
-                let mut lib_tgt = None;
-                for tgt in pkg.targets(&ws.cargo) {
-                    let root = tgt.root(&ws.cargo);
-                    if let Some(file_id) = vfs.load(root) {
-                        let file_id = FileId(file_id.0.into());
-                        let crate_id = crate_graph.add_crate_root(file_id);
-                        if tgt.kind(&ws.cargo) == TargetKind::Lib {
-                            lib_tgt = Some(crate_id);
-                            pkg_to_lib_crate.insert(pkg, crate_id);
-                        }
-                        pkg_crates.entry(pkg).or_insert_with(Vec::new).push(crate_id);
-                    }
-                }
-
-                // Set deps to the std and to the lib target of the current package
-                for &from in pkg_crates.get(&pkg).into_iter().flatten() {
-                    if let Some(to) = lib_tgt {
-                        if to != from {
-                            if let Err(_) =
-                                crate_graph.add_dep(from, pkg.name(&ws.cargo).into(), to)
-                            {
-                                log::error!(
-                                    "cyclic dependency between targets of {}",
-                                    pkg.name(&ws.cargo)
-                                )
-                            }
-                        }
-                    }
-                    if let Some(std) = libstd {
-                        if let Err(_) = crate_graph.add_dep(from, "std".into(), std) {
-                            log::error!("cyclic dependency on std for {}", pkg.name(&ws.cargo))
-                        }
-                    }
-                }
-            }
-
-            // Now add a dep ednge from all targets of upstream to the lib
-            // target of downstream.
-            for pkg in ws.cargo.packages() {
-                for dep in pkg.dependencies(&ws.cargo) {
-                    if let Some(&to) = pkg_to_lib_crate.get(&dep.pkg) {
-                        for &from in pkg_crates.get(&pkg).into_iter().flatten() {
-                            if let Err(_) = crate_graph.add_dep(from, dep.name.clone(), to) {
-                                log::error!(
-                                    "cyclic dependency {} -> {}",
-                                    pkg.name(&ws.cargo),
-                                    dep.pkg.name(&ws.cargo)
-                                )
-                            }
-                        }
-                    }
-                }
-            }
+            crate_graph.extend(ws.to_crate_graph(&mut load));
         }
         change.set_crate_graph(crate_graph);
 

crates/ra_lsp_server/src/server_world.rs

@@ -0,0 +1,21 @@
+[package]
+edition = "2018"
+name = "ra_project_model"
+version = "0.1.0"
+authors = ["Aleksey Kladov <[email protected]>"]
+
+[dependencies]
+log = "0.4.5"
+rustc-hash = "1.0"
+
+failure = "0.1.4"
+
+walkdir = "2.2.7"
+
+cargo_metadata = "0.7.0"
+
+ra_arena = { path = "../ra_arena" }
+ra_db = { path = "../ra_db" }
+
+[dev-dependencies]
+test_utils = { path = "../test_utils" }

crates/ra_project_model/Cargo.toml

@@ -1,17 +1,16 @@
 use std::path::{Path, PathBuf};
 
 use cargo_metadata::{MetadataCommand, CargoOpt};
-use ra_syntax::SmolStr;
 use ra_arena::{Arena, RawId, impl_arena_id};
 use rustc_hash::FxHashMap;
 use failure::format_err;
 
 use crate::Result;
 
-/// `CargoWorksapce` represents the logical structure of, well, a Cargo
+/// `CargoWorkspace` represents the logical structure of, well, a Cargo
 /// workspace. It pretty closely mirrors `cargo metadata` output.
 ///
-/// Note that internally, rust analyzer uses a differnet structure:
+/// Note that internally, rust analyzer uses a different structure:
 /// `CrateGraph`. `CrateGraph` is lower-level: it knows only about the crates,
 /// while this knows about `Pacakges` & `Targets`: purely cargo-related
 /// concepts.
@@ -31,7 +30,7 @@ impl_arena_id!(Target);
 
 #[derive(Debug, Clone)]
 struct PackageData {
-    name: SmolStr,
+    name: String,
     manifest: PathBuf,
     targets: Vec<Target>,
     is_member: bool,
@@ -41,13 +40,13 @@ struct PackageData {
 #[derive(Debug, Clone)]
 pub struct PackageDependency {
     pub pkg: Package,
-    pub name: SmolStr,
+    pub name: String,
 }
 
 #[derive(Debug, Clone)]
 struct TargetData {
     pkg: Package,
-    name: SmolStr,
+    name: String,
     root: PathBuf,
     kind: TargetKind,
 }
@@ -162,9 +161,11 @@ impl CargoWorkspace {
 
         Ok(CargoWorkspace { packages, targets })
     }
+
     pub fn packages<'a>(&'a self) -> impl Iterator<Item = Package> + 'a {
         self.packages.iter().map(|(id, _pkg)| id)
     }
+
     pub fn target_by_root(&self, root: &Path) -> Option<Target> {
         self.packages().filter_map(|pkg| pkg.targets(self).find(|it| it.root(self) == root)).next()
     }