From fcd615e4b76264b4fff7b5be454787bb6a4252ea Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Tue, 5 Feb 2019 23:10:49 +0100 Subject: Extract project model to separate crate --- crates/ra_project_model/src/cargo_workspace.rs | 173 +++++++++++++++++++++++++ crates/ra_project_model/src/lib.rs | 45 +++++++ crates/ra_project_model/src/sysroot.rs | 138 ++++++++++++++++++++ 3 files changed, 356 insertions(+) create mode 100644 crates/ra_project_model/src/cargo_workspace.rs create mode 100644 crates/ra_project_model/src/lib.rs create mode 100644 crates/ra_project_model/src/sysroot.rs (limited to 'crates/ra_project_model/src') diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs new file mode 100644 index 000000000..f3e67d0e5 --- /dev/null +++ b/crates/ra_project_model/src/cargo_workspace.rs @@ -0,0 +1,173 @@ +use std::path::{Path, PathBuf}; + +use cargo_metadata::{MetadataCommand, CargoOpt}; +use smol_str::SmolStr; +use ra_arena::{Arena, RawId, impl_arena_id}; +use rustc_hash::FxHashMap; +use failure::format_err; + +use crate::Result; + +/// `CargoWorkspace` represents the logical structure of, well, a Cargo +/// workspace. It pretty closely mirrors `cargo metadata` output. +/// +/// 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. +#[derive(Debug, Clone)] +pub struct CargoWorkspace { + packages: Arena, + targets: Arena, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub struct Package(RawId); +impl_arena_id!(Package); + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub struct Target(RawId); +impl_arena_id!(Target); + +#[derive(Debug, Clone)] +struct PackageData { + name: SmolStr, + manifest: PathBuf, + targets: Vec, + is_member: bool, + dependencies: Vec, +} + +#[derive(Debug, Clone)] +pub struct PackageDependency { + pub pkg: Package, + pub name: SmolStr, +} + +#[derive(Debug, Clone)] +struct TargetData { + pkg: Package, + name: SmolStr, + root: PathBuf, + kind: TargetKind, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum TargetKind { + Bin, + Lib, + Example, + Test, + Bench, + Other, +} + +impl TargetKind { + fn new(kinds: &[String]) -> TargetKind { + for kind in kinds { + return match kind.as_str() { + "bin" => TargetKind::Bin, + "test" => TargetKind::Test, + "bench" => TargetKind::Bench, + "example" => TargetKind::Example, + _ if kind.contains("lib") => TargetKind::Lib, + _ => continue, + }; + } + TargetKind::Other + } +} + +impl Package { + pub fn name(self, ws: &CargoWorkspace) -> &str { + ws.packages[self].name.as_str() + } + pub fn root(self, ws: &CargoWorkspace) -> &Path { + ws.packages[self].manifest.parent().unwrap() + } + pub fn targets<'a>(self, ws: &'a CargoWorkspace) -> impl Iterator + 'a { + ws.packages[self].targets.iter().cloned() + } + #[allow(unused)] + pub fn is_member(self, ws: &CargoWorkspace) -> bool { + ws.packages[self].is_member + } + pub fn dependencies<'a>( + self, + ws: &'a CargoWorkspace, + ) -> impl Iterator + 'a { + ws.packages[self].dependencies.iter() + } +} + +impl Target { + pub fn package(self, ws: &CargoWorkspace) -> Package { + ws.targets[self].pkg + } + pub fn name(self, ws: &CargoWorkspace) -> &str { + ws.targets[self].name.as_str() + } + pub fn root(self, ws: &CargoWorkspace) -> &Path { + ws.targets[self].root.as_path() + } + pub fn kind(self, ws: &CargoWorkspace) -> TargetKind { + ws.targets[self].kind + } +} + +impl CargoWorkspace { + pub fn from_cargo_metadata(cargo_toml: &Path) -> Result { + let mut meta = MetadataCommand::new(); + meta.manifest_path(cargo_toml).features(CargoOpt::AllFeatures); + if let Some(parent) = cargo_toml.parent() { + meta.current_dir(parent); + } + let meta = meta.exec().map_err(|e| format_err!("cargo metadata failed: {}", e))?; + let mut pkg_by_id = FxHashMap::default(); + let mut packages = Arena::default(); + let mut targets = Arena::default(); + + let ws_members = &meta.workspace_members; + + for meta_pkg in meta.packages { + let is_member = ws_members.contains(&meta_pkg.id); + let pkg = packages.alloc(PackageData { + name: meta_pkg.name.into(), + manifest: meta_pkg.manifest_path.clone(), + targets: Vec::new(), + is_member, + dependencies: Vec::new(), + }); + let pkg_data = &mut packages[pkg]; + pkg_by_id.insert(meta_pkg.id.clone(), pkg); + for meta_tgt in meta_pkg.targets { + let tgt = targets.alloc(TargetData { + pkg, + name: meta_tgt.name.into(), + root: meta_tgt.src_path.clone(), + kind: TargetKind::new(meta_tgt.kind.as_slice()), + }); + pkg_data.targets.push(tgt); + } + } + let resolve = meta.resolve.expect("metadata executed with deps"); + for node in resolve.nodes { + let source = pkg_by_id[&node.id]; + for dep_node in node.deps { + let dep = + PackageDependency { name: dep_node.name.into(), pkg: pkg_by_id[&dep_node.pkg] }; + packages[source].dependencies.push(dep); + } + } + + Ok(CargoWorkspace { packages, targets }) + } + + pub fn packages<'a>(&'a self) -> impl Iterator + 'a { + self.packages.iter().map(|(id, _pkg)| id) + } + + pub fn target_by_root(&self, root: &Path) -> Option { + self.packages().filter_map(|pkg| pkg.targets(self).find(|it| it.root(self) == root)).next() + } +} diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs new file mode 100644 index 000000000..3a7bbace7 --- /dev/null +++ b/crates/ra_project_model/src/lib.rs @@ -0,0 +1,45 @@ +mod cargo_workspace; +mod sysroot; + +use std::path::{Path, PathBuf}; + +use failure::bail; + +pub use crate::{ + cargo_workspace::{CargoWorkspace, Package, Target, TargetKind}, + sysroot::Sysroot, +}; + +// TODO use own error enum? +pub type Result = ::std::result::Result; + +#[derive(Debug, Clone)] +pub struct ProjectWorkspace { + pub cargo: CargoWorkspace, + pub sysroot: Sysroot, +} + +impl ProjectWorkspace { + pub fn discover(path: &Path) -> Result { + 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) + } +} + +fn find_cargo_toml(path: &Path) -> Result { + 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()) +} diff --git a/crates/ra_project_model/src/sysroot.rs b/crates/ra_project_model/src/sysroot.rs new file mode 100644 index 000000000..18824dbe5 --- /dev/null +++ b/crates/ra_project_model/src/sysroot.rs @@ -0,0 +1,138 @@ +use std::{ + path::{Path, PathBuf}, + process::Command, +}; + +use smol_str::SmolStr; + +use ra_arena::{Arena, RawId, impl_arena_id}; + +use crate::Result; + +#[derive(Debug, Clone)] +pub struct Sysroot { + crates: Arena, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct SysrootCrate(RawId); +impl_arena_id!(SysrootCrate); + +#[derive(Debug, Clone)] +struct SysrootCrateData { + name: SmolStr, + root: PathBuf, + deps: Vec, +} + +impl Sysroot { + pub fn std(&self) -> Option { + self.by_name("std") + } + + pub fn crates<'a>(&'a self) -> impl Iterator + 'a { + self.crates.iter().map(|(id, _data)| id) + } + + pub fn discover(cargo_toml: &Path) -> Result { + let rustc_output = Command::new("rustc") + .current_dir(cargo_toml.parent().unwrap()) + .args(&["--print", "sysroot"]) + .output()?; + if !rustc_output.status.success() { + failure::bail!("failed to locate sysroot") + } + let stdout = String::from_utf8(rustc_output.stdout)?; + let sysroot_path = Path::new(stdout.trim()); + let src = sysroot_path.join("lib/rustlib/src/rust/src"); + if !src.exists() { + failure::bail!( + "can't load standard library from sysroot\n\ + {:?}\n\ + try running `rustup component add rust-src`", + src, + ); + } + + let mut sysroot = Sysroot { crates: Arena::default() }; + for name in SYSROOT_CRATES.trim().lines() { + let root = src.join(format!("lib{}", name)).join("lib.rs"); + if root.exists() { + sysroot.crates.alloc(SysrootCrateData { + name: name.into(), + root, + deps: Vec::new(), + }); + } + } + if let Some(std) = sysroot.std() { + for dep in STD_DEPS.trim().lines() { + if let Some(dep) = sysroot.by_name(dep) { + sysroot.crates[std].deps.push(dep) + } + } + } + Ok(sysroot) + } + + fn by_name(&self, name: &str) -> Option { + self.crates.iter().find(|(_id, data)| data.name == name).map(|(id, _data)| id) + } +} + +impl SysrootCrate { + pub fn name(self, sysroot: &Sysroot) -> &SmolStr { + &sysroot.crates[self].name + } + pub fn root(self, sysroot: &Sysroot) -> &Path { + sysroot.crates[self].root.as_path() + } + pub fn root_dir(self, sysroot: &Sysroot) -> &Path { + self.root(sysroot).parent().unwrap() + } + pub fn deps<'a>(self, sysroot: &'a Sysroot) -> impl Iterator + 'a { + sysroot.crates[self].deps.iter().map(|&it| it) + } +} + +const SYSROOT_CRATES: &str = " +std +core +alloc +collections +libc +panic_unwind +proc_macro +rustc_unicode +std_unicode +test +alloc_jemalloc +alloc_system +compiler_builtins +getopts +panic_unwind +panic_abort +rand +term +unwind +build_helper +rustc_asan +rustc_lsan +rustc_msan +rustc_tsan +syntax"; + +const STD_DEPS: &str = " +alloc +alloc_jemalloc +alloc_system +core +panic_abort +rand +compiler_builtins +unwind +rustc_asan +rustc_lsan +rustc_msan +rustc_tsan +build_helper"; -- cgit v1.2.3 From ddbf43b630fa8159ab2ea5e959393bff44e0c73b Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Wed, 6 Feb 2019 22:54:33 +0100 Subject: Move crate graph generation to ra_project_model --- crates/ra_project_model/src/lib.rs | 88 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) (limited to 'crates/ra_project_model/src') diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs index 3a7bbace7..30612ac84 100644 --- a/crates/ra_project_model/src/lib.rs +++ b/crates/ra_project_model/src/lib.rs @@ -4,6 +4,10 @@ mod sysroot; use std::path::{Path, PathBuf}; use failure::bail; +use rustc_hash::FxHashMap; + +use ra_db::{CrateGraph, FileId}; +use ra_vfs::Vfs; pub use crate::{ cargo_workspace::{CargoWorkspace, Package, Target, TargetKind}, @@ -27,6 +31,90 @@ impl ProjectWorkspace { let res = ProjectWorkspace { cargo, sysroot }; Ok(res) } + + pub fn to_crate_graph(&self, vfs: &mut Vfs) -> CrateGraph { + let mut crate_graph = CrateGraph::default(); + let mut sysroot_crates = FxHashMap::default(); + for krate in self.sysroot.crates() { + if let Some(file_id) = vfs.load(krate.root(&self.sysroot)) { + let file_id = FileId(file_id.0.into()); + sysroot_crates.insert(krate, crate_graph.add_crate_root(file_id)); + } + } + for from in self.sysroot.crates() { + for to in from.deps(&self.sysroot) { + let name = to.name(&self.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 = self.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 self.cargo.packages() { + let mut lib_tgt = None; + for tgt in pkg.targets(&self.cargo) { + let root = tgt.root(&self.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(&self.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(&self.cargo).into(), to) + { + log::error!( + "cyclic dependency between targets of {}", + pkg.name(&self.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(&self.cargo)) + } + } + } + } + + // Now add a dep ednge from all targets of upstream to the lib + // target of downstream. + for pkg in self.cargo.packages() { + for dep in pkg.dependencies(&self.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(&self.cargo), + dep.pkg.name(&self.cargo) + ) + } + } + } + } + } + + crate_graph + } } fn find_cargo_toml(path: &Path) -> Result { -- cgit v1.2.3 From 12c70871cca736afa44379e59f8573c60b0ccd0a Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Sat, 9 Feb 2019 10:51:06 +0100 Subject: Remove SmolStr from project model --- crates/ra_project_model/src/cargo_workspace.rs | 7 +++---- crates/ra_project_model/src/lib.rs | 4 ++-- crates/ra_project_model/src/sysroot.rs | 6 ++---- 3 files changed, 7 insertions(+), 10 deletions(-) (limited to 'crates/ra_project_model/src') diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs index f3e67d0e5..8adf463a6 100644 --- a/crates/ra_project_model/src/cargo_workspace.rs +++ b/crates/ra_project_model/src/cargo_workspace.rs @@ -1,7 +1,6 @@ use std::path::{Path, PathBuf}; use cargo_metadata::{MetadataCommand, CargoOpt}; -use smol_str::SmolStr; use ra_arena::{Arena, RawId, impl_arena_id}; use rustc_hash::FxHashMap; use failure::format_err; @@ -31,7 +30,7 @@ impl_arena_id!(Target); #[derive(Debug, Clone)] struct PackageData { - name: SmolStr, + name: String, manifest: PathBuf, targets: Vec, 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, } diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs index 30612ac84..abc79684c 100644 --- a/crates/ra_project_model/src/lib.rs +++ b/crates/ra_project_model/src/lib.rs @@ -47,7 +47,7 @@ impl ProjectWorkspace { 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) { + if let Err(_) = crate_graph.add_dep(from, name.into(), to) { log::error!("cyclic dependency between sysroot crates") } } @@ -101,7 +101,7 @@ impl ProjectWorkspace { for dep in pkg.dependencies(&self.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) { + if let Err(_) = crate_graph.add_dep(from, dep.name.clone().into(), to) { log::error!( "cyclic dependency {} -> {}", pkg.name(&self.cargo), diff --git a/crates/ra_project_model/src/sysroot.rs b/crates/ra_project_model/src/sysroot.rs index 18824dbe5..8b87aa7bd 100644 --- a/crates/ra_project_model/src/sysroot.rs +++ b/crates/ra_project_model/src/sysroot.rs @@ -3,8 +3,6 @@ use std::{ process::Command, }; -use smol_str::SmolStr; - use ra_arena::{Arena, RawId, impl_arena_id}; use crate::Result; @@ -20,7 +18,7 @@ impl_arena_id!(SysrootCrate); #[derive(Debug, Clone)] struct SysrootCrateData { - name: SmolStr, + name: String, root: PathBuf, deps: Vec, } @@ -81,7 +79,7 @@ impl Sysroot { } impl SysrootCrate { - pub fn name(self, sysroot: &Sysroot) -> &SmolStr { + pub fn name(self, sysroot: &Sysroot) -> &str { &sysroot.crates[self].name } pub fn root(self, sysroot: &Sysroot) -> &Path { -- cgit v1.2.3 From 50fd860471f577e9bb7536e74eb181c055033183 Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Sat, 9 Feb 2019 11:08:24 +0100 Subject: Remove Vfs from project model --- crates/ra_project_model/src/lib.rs | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) (limited to 'crates/ra_project_model/src') diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs index abc79684c..156af9e7a 100644 --- a/crates/ra_project_model/src/lib.rs +++ b/crates/ra_project_model/src/lib.rs @@ -7,7 +7,6 @@ use failure::bail; use rustc_hash::FxHashMap; use ra_db::{CrateGraph, FileId}; -use ra_vfs::Vfs; pub use crate::{ cargo_workspace::{CargoWorkspace, Package, Target, TargetKind}, @@ -32,12 +31,11 @@ impl ProjectWorkspace { Ok(res) } - pub fn to_crate_graph(&self, vfs: &mut Vfs) -> CrateGraph { + pub fn to_crate_graph(&self, load: &mut dyn FnMut(&Path) -> Option) -> CrateGraph { let mut crate_graph = CrateGraph::default(); let mut sysroot_crates = FxHashMap::default(); for krate in self.sysroot.crates() { - if let Some(file_id) = vfs.load(krate.root(&self.sysroot)) { - let file_id = FileId(file_id.0.into()); + if let Some(file_id) = load(krate.root(&self.sysroot)) { sysroot_crates.insert(krate, crate_graph.add_crate_root(file_id)); } } @@ -63,8 +61,7 @@ impl ProjectWorkspace { let mut lib_tgt = None; for tgt in pkg.targets(&self.cargo) { let root = tgt.root(&self.cargo); - if let Some(file_id) = vfs.load(root) { - let file_id = FileId(file_id.0.into()); + if let Some(file_id) = load(root) { let crate_id = crate_graph.add_crate_root(file_id); if tgt.kind(&self.cargo) == TargetKind::Lib { lib_tgt = Some(crate_id); -- cgit v1.2.3 From e91a46eb0c4a355af25656d77dead55c2e29258e Mon Sep 17 00:00:00 2001 From: Florian Diebold Date: Sat, 9 Feb 2019 11:15:02 +0100 Subject: Clean up a bit --- crates/ra_project_model/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'crates/ra_project_model/src') diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs index 156af9e7a..3b1e07149 100644 --- a/crates/ra_project_model/src/lib.rs +++ b/crates/ra_project_model/src/lib.rs @@ -13,7 +13,7 @@ pub use crate::{ sysroot::Sysroot, }; -// TODO use own error enum? +// TODO use proper error enum pub type Result = ::std::result::Result; #[derive(Debug, Clone)] -- cgit v1.2.3