1 //! FIXME: write short doc here
8 fs::{read_dir, File, ReadDir},
11 process::{Command, Output},
14 use anyhow::{bail, Context, Result};
15 use paths::{AbsPath, AbsPathBuf};
16 use ra_cfg::CfgOptions;
17 use ra_db::{CrateGraph, CrateName, Edition, Env, FileId};
18 use rustc_hash::{FxHashMap, FxHashSet};
19 use serde_json::from_reader;
22 cargo_workspace::{CargoConfig, CargoWorkspace, Package, Target, TargetKind},
23 project_json::ProjectJson,
26 pub use ra_proc_macro::ProcMacroClient;
28 #[derive(Debug, Clone)]
29 pub enum ProjectWorkspace {
30 /// Project workspace was discovered by running `cargo metadata` and `rustc --print sysroot`.
31 Cargo { cargo: CargoWorkspace, sysroot: Sysroot },
32 /// Project workspace was manually specified using a `rust-project.json` file.
33 Json { project: ProjectJson, project_location: AbsPathBuf },
36 /// `PackageRoot` describes a package root folder.
37 /// Which may be an external dependency, or a member of
38 /// the current workspace.
39 #[derive(Debug, Clone)]
40 pub struct PackageRoot {
41 /// Path to the root folder
43 /// Is a member of the current workspace
45 out_dir: Option<AbsPathBuf>,
48 pub fn new_member(path: AbsPathBuf) -> PackageRoot {
49 Self { path, is_member: true, out_dir: None }
51 pub fn new_non_member(path: AbsPathBuf) -> PackageRoot {
52 Self { path, is_member: false, out_dir: None }
54 pub fn path(&self) -> &AbsPath {
57 pub fn out_dir(&self) -> Option<&AbsPath> {
58 self.out_dir.as_deref()
60 pub fn is_member(&self) -> bool {
65 #[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
66 pub enum ProjectManifest {
67 ProjectJson(AbsPathBuf),
68 CargoToml(AbsPathBuf),
71 impl ProjectManifest {
72 pub fn from_manifest_file(path: AbsPathBuf) -> Result<ProjectManifest> {
73 if path.ends_with("rust-project.json") {
74 return Ok(ProjectManifest::ProjectJson(path));
76 if path.ends_with("Cargo.toml") {
77 return Ok(ProjectManifest::CargoToml(path));
79 bail!("project root must point to Cargo.toml or rust-project.json: {}", path.display())
82 pub fn discover_single(path: &AbsPath) -> Result<ProjectManifest> {
83 let mut candidates = ProjectManifest::discover(path)?;
84 let res = match candidates.pop() {
85 None => bail!("no projects"),
89 if !candidates.is_empty() {
90 bail!("more than one project")
95 pub fn discover(path: &AbsPath) -> io::Result<Vec<ProjectManifest>> {
96 if let Some(project_json) = find_in_parent_dirs(path, "rust-project.json") {
97 return Ok(vec![ProjectManifest::ProjectJson(project_json)]);
99 return find_cargo_toml(path)
100 .map(|paths| paths.into_iter().map(ProjectManifest::CargoToml).collect());
102 fn find_cargo_toml(path: &AbsPath) -> io::Result<Vec<AbsPathBuf>> {
103 match find_in_parent_dirs(path, "Cargo.toml") {
104 Some(it) => Ok(vec![it]),
105 None => Ok(find_cargo_toml_in_child_dir(read_dir(path)?)),
109 fn find_in_parent_dirs(path: &AbsPath, target_file_name: &str) -> Option<AbsPathBuf> {
110 if path.ends_with(target_file_name) {
111 return Some(path.to_path_buf());
114 let mut curr = Some(path);
116 while let Some(path) = curr {
117 let candidate = path.join(target_file_name);
118 if candidate.exists() {
119 return Some(candidate);
121 curr = path.parent();
127 fn find_cargo_toml_in_child_dir(entities: ReadDir) -> Vec<AbsPathBuf> {
128 // Only one level down to avoid cycles the easy way and stop a runaway scan with large projects
130 .filter_map(Result::ok)
131 .map(|it| it.path().join("Cargo.toml"))
132 .filter(|it| it.exists())
133 .map(AbsPathBuf::assert)
138 pub fn discover_all(paths: &[impl AsRef<AbsPath>]) -> Vec<ProjectManifest> {
141 .filter_map(|it| ProjectManifest::discover(it.as_ref()).ok())
143 .collect::<FxHashSet<_>>()
145 .collect::<Vec<_>>();
151 impl ProjectWorkspace {
153 manifest: ProjectManifest,
154 cargo_features: &CargoConfig,
156 ) -> Result<ProjectWorkspace> {
157 let res = match manifest {
158 ProjectManifest::ProjectJson(project_json) => {
159 let file = File::open(&project_json).with_context(|| {
160 format!("Failed to open json file {}", project_json.display())
162 let reader = BufReader::new(file);
163 let project_location = project_json.parent().unwrap().to_path_buf();
164 ProjectWorkspace::Json {
165 project: from_reader(reader).with_context(|| {
166 format!("Failed to deserialize json file {}", project_json.display())
171 ProjectManifest::CargoToml(cargo_toml) => {
172 let cargo = CargoWorkspace::from_cargo_metadata(&cargo_toml, cargo_features)
175 "Failed to read Cargo metadata from Cargo.toml file {}",
179 let sysroot = if with_sysroot {
180 Sysroot::discover(&cargo_toml).with_context(|| {
182 "Failed to find sysroot for Cargo.toml file {}. Is rust-src installed?",
189 ProjectWorkspace::Cargo { cargo, sysroot }
196 /// Returns the roots for the current `ProjectWorkspace`
197 /// The return type contains the path and whether or not
198 /// the root is a member of the current workspace
199 pub fn to_roots(&self) -> Vec<PackageRoot> {
201 ProjectWorkspace::Json { project, project_location } => project
204 .map(|r| PackageRoot::new_member(project_location.join(&r.path)))
206 ProjectWorkspace::Cargo { cargo, sysroot } => cargo
208 .map(|pkg| PackageRoot {
209 path: cargo[pkg].root().to_path_buf(),
210 is_member: cargo[pkg].is_member,
211 out_dir: cargo[pkg].out_dir.clone(),
213 .chain(sysroot.crates().map(|krate| {
214 PackageRoot::new_non_member(sysroot[krate].root_dir().to_path_buf())
220 pub fn proc_macro_dylib_paths(&self) -> Vec<AbsPathBuf> {
222 ProjectWorkspace::Json { project, project_location } => project
225 .filter_map(|krate| krate.proc_macro_dylib_path.as_ref())
226 .map(|it| project_location.join(it))
228 ProjectWorkspace::Cargo { cargo, sysroot: _sysroot } => cargo
230 .filter_map(|pkg| cargo[pkg].proc_macro_dylib_path.as_ref())
236 pub fn n_packages(&self) -> usize {
238 ProjectWorkspace::Json { project, .. } => project.crates.len(),
239 ProjectWorkspace::Cargo { cargo, sysroot } => {
240 cargo.packages().len() + sysroot.crates().len()
245 pub fn to_crate_graph(
247 target: Option<&str>,
248 proc_macro_client: &ProcMacroClient,
249 load: &mut dyn FnMut(&Path) -> Option<FileId>,
251 let mut crate_graph = CrateGraph::default();
253 ProjectWorkspace::Json { project, project_location } => {
254 let crates: FxHashMap<_, _> = project
258 .filter_map(|(seq_index, krate)| {
259 let file_path = project_location.join(&krate.root_module);
260 let file_id = load(&file_path)?;
261 let edition = match krate.edition {
262 project_json::Edition::Edition2015 => Edition::Edition2015,
263 project_json::Edition::Edition2018 => Edition::Edition2018,
266 let mut opts = CfgOptions::default();
267 for cfg in &krate.cfg {
268 match cfg.find('=') {
269 None => opts.insert_atom(cfg.into()),
271 let key = &cfg[..pos];
272 let value = cfg[pos + 1..].trim_matches('"');
273 opts.insert_key_value(key.into(), value.into());
280 let mut env = Env::default();
281 if let Some(out_dir) = &krate.out_dir {
282 // NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!()
283 if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) {
284 env.set("OUT_DIR", out_dir);
287 let proc_macro = krate
288 .proc_macro_dylib_path
290 .map(|it| proc_macro_client.by_dylib_path(&it));
291 // FIXME: No crate name in json definition such that we cannot add OUT_DIR to env
293 project_json::CrateId(seq_index),
294 crate_graph.add_crate_root(
297 // FIXME json definitions can store the crate name
301 proc_macro.unwrap_or_default(),
307 for (id, krate) in project.crates.iter().enumerate() {
308 for dep in &krate.deps {
309 let from_crate_id = project_json::CrateId(id);
310 let to_crate_id = dep.krate;
311 if let (Some(&from), Some(&to)) =
312 (crates.get(&from_crate_id), crates.get(&to_crate_id))
315 .add_dep(from, CrateName::new(&dep.name).unwrap(), to)
319 "cyclic dependency {:?} -> {:?}",
328 ProjectWorkspace::Cargo { cargo, sysroot } => {
329 let mut cfg_options = get_rustc_cfg_options(target);
331 let sysroot_crates: FxHashMap<_, _> = sysroot
333 .filter_map(|krate| {
334 let file_id = load(&sysroot[krate].root)?;
336 let env = Env::default();
337 let proc_macro = vec![];
338 let crate_name = CrateName::new(&sysroot[krate].name)
339 .expect("Sysroot crate names should not contain dashes");
341 let crate_id = crate_graph.add_crate_root(
343 Edition::Edition2018,
349 Some((krate, crate_id))
353 for from in sysroot.crates() {
354 for &to in sysroot[from].deps.iter() {
355 let name = &sysroot[to].name;
356 if let (Some(&from), Some(&to)) =
357 (sysroot_crates.get(&from), sysroot_crates.get(&to))
359 if crate_graph.add_dep(from, CrateName::new(name).unwrap(), to).is_err()
361 log::error!("cyclic dependency between sysroot crates")
367 let libcore = sysroot.core().and_then(|it| sysroot_crates.get(&it).copied());
368 let liballoc = sysroot.alloc().and_then(|it| sysroot_crates.get(&it).copied());
369 let libstd = sysroot.std().and_then(|it| sysroot_crates.get(&it).copied());
371 sysroot.proc_macro().and_then(|it| sysroot_crates.get(&it).copied());
373 let mut pkg_to_lib_crate = FxHashMap::default();
374 let mut pkg_crates = FxHashMap::default();
376 // Add test cfg for non-sysroot crates
377 cfg_options.insert_atom("test".into());
379 // Next, create crates for each package, target pair
380 for pkg in cargo.packages() {
381 let mut lib_tgt = None;
382 for &tgt in cargo[pkg].targets.iter() {
383 let root = cargo[tgt].root.as_path();
384 if let Some(file_id) = load(root) {
385 let edition = cargo[pkg].edition;
387 let mut opts = cfg_options.clone();
388 for feature in cargo[pkg].features.iter() {
389 opts.insert_key_value("feature".into(), feature.into());
391 for cfg in cargo[pkg].cfgs.iter() {
392 match cfg.find('=') {
393 Some(split) => opts.insert_key_value(
395 cfg[split + 1..].trim_matches('"').into(),
397 None => opts.insert_atom(cfg.into()),
402 let mut env = Env::default();
403 if let Some(out_dir) = &cargo[pkg].out_dir {
404 // NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!()
405 if let Some(out_dir) = out_dir.to_str().map(|s| s.to_owned()) {
406 env.set("OUT_DIR", out_dir);
409 let proc_macro = cargo[pkg]
410 .proc_macro_dylib_path
412 .map(|it| proc_macro_client.by_dylib_path(&it))
413 .unwrap_or_default();
415 let crate_id = crate_graph.add_crate_root(
418 Some(CrateName::normalize_dashes(&cargo[pkg].name)),
423 if cargo[tgt].kind == TargetKind::Lib {
424 lib_tgt = Some((crate_id, cargo[tgt].name.clone()));
425 pkg_to_lib_crate.insert(pkg, crate_id);
427 if cargo[tgt].is_proc_macro {
428 if let Some(proc_macro) = libproc_macro {
432 CrateName::new("proc_macro").unwrap(),
438 "cyclic dependency on proc_macro for {}",
445 pkg_crates.entry(pkg).or_insert_with(Vec::new).push(crate_id);
449 // Set deps to the core, std and to the lib target of the current package
450 for &from in pkg_crates.get(&pkg).into_iter().flatten() {
451 if let Some((to, name)) = lib_tgt.clone() {
456 // For root projects with dashes in their name,
457 // cargo metadata does not do any normalization,
458 // so we do it ourselves currently
459 CrateName::normalize_dashes(&name),
466 "cyclic dependency between targets of {}",
472 // core is added as a dependency before std in order to
473 // mimic rustcs dependency order
474 if let Some(core) = libcore {
476 .add_dep(from, CrateName::new("core").unwrap(), core)
479 log::error!("cyclic dependency on core for {}", &cargo[pkg].name)
482 if let Some(alloc) = liballoc {
484 .add_dep(from, CrateName::new("alloc").unwrap(), alloc)
487 log::error!("cyclic dependency on alloc for {}", &cargo[pkg].name)
490 if let Some(std) = libstd {
492 .add_dep(from, CrateName::new("std").unwrap(), std)
495 log::error!("cyclic dependency on std for {}", &cargo[pkg].name)
501 // Now add a dep edge from all targets of upstream to the lib
502 // target of downstream.
503 for pkg in cargo.packages() {
504 for dep in cargo[pkg].dependencies.iter() {
505 if let Some(&to) = pkg_to_lib_crate.get(&dep.pkg) {
506 for &from in pkg_crates.get(&pkg).into_iter().flatten() {
508 .add_dep(from, CrateName::new(&dep.name).unwrap(), to)
512 "cyclic dependency {} -> {}",
526 pub fn workspace_root_for(&self, path: &Path) -> Option<&Path> {
528 ProjectWorkspace::Cargo { cargo, .. } => {
529 Some(cargo.workspace_root()).filter(|root| path.starts_with(root))
531 ProjectWorkspace::Json { project: ProjectJson { roots, .. }, .. } => roots
533 .find(|root| path.starts_with(&root.path))
534 .map(|root| root.path.as_ref()),
539 fn get_rustc_cfg_options(target: Option<&str>) -> CfgOptions {
540 let mut cfg_options = CfgOptions::default();
542 // Some nightly-only cfgs, which are required for stdlib
544 cfg_options.insert_atom("target_thread_local".into());
545 for &target_has_atomic in ["8", "16", "32", "64", "cas", "ptr"].iter() {
546 cfg_options.insert_key_value("target_has_atomic".into(), target_has_atomic.into());
548 .insert_key_value("target_has_atomic_load_store".into(), target_has_atomic.into());
552 let rustc_cfgs = || -> Result<String> {
553 // `cfg(test)` and `cfg(debug_assertion)` are handled outside, so we suppress them here.
554 let mut cmd = Command::new(ra_toolchain::rustc());
555 cmd.args(&["--print", "cfg", "-O"]);
556 if let Some(target) = target {
557 cmd.args(&["--target", target]);
559 let output = output(cmd)?;
560 Ok(String::from_utf8(output.stdout)?)
565 for line in rustc_cfgs.lines() {
566 match line.find('=') {
567 None => cfg_options.insert_atom(line.into()),
569 let key = &line[..pos];
570 let value = line[pos + 1..].trim_matches('"');
571 cfg_options.insert_key_value(key.into(), value.into());
576 Err(e) => log::error!("failed to get rustc cfgs: {:#}", e),
579 cfg_options.insert_atom("debug_assertions".into());
584 fn output(mut cmd: Command) -> Result<Output> {
585 let output = cmd.output().with_context(|| format!("{:?} failed", cmd))?;
586 if !output.status.success() {
587 match String::from_utf8(output.stderr) {
588 Ok(stderr) if !stderr.is_empty() => {
589 bail!("{:?} failed, {}\nstderr:\n{}", cmd, output.status, stderr)
591 _ => bail!("{:?} failed, {}", cmd, output.status),