Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'crates/project-model/src/sysroot.rs')
| -rw-r--r-- | crates/project-model/src/sysroot.rs | 221 |
1 files changed, 221 insertions, 0 deletions
diff --git a/crates/project-model/src/sysroot.rs b/crates/project-model/src/sysroot.rs new file mode 100644 index 0000000000..52750f4896 --- /dev/null +++ b/crates/project-model/src/sysroot.rs @@ -0,0 +1,221 @@ +//! Loads "sysroot" crate. +//! +//! One confusing point here is that normally sysroot is a bunch of `.rlib`s, +//! but we can't process `.rlib` and need source code instead. The source code +//! is typically installed with `rustup component add rust-src` command. + +use std::{env, fs, iter, ops, path::PathBuf, process::Command}; + +use anyhow::{format_err, Result}; +use la_arena::{Arena, Idx}; +use paths::{AbsPath, AbsPathBuf}; + +use crate::{utf8_stdout, ManifestPath}; + +#[derive(Debug, Clone, Eq, PartialEq)] +pub struct Sysroot { + root: AbsPathBuf, + crates: Arena<SysrootCrateData>, +} + +pub(crate) type SysrootCrate = Idx<SysrootCrateData>; + +#[derive(Debug, Clone, Eq, PartialEq)] +pub struct SysrootCrateData { + pub name: String, + pub root: ManifestPath, + pub deps: Vec<SysrootCrate>, +} + +impl ops::Index<SysrootCrate> for Sysroot { + type Output = SysrootCrateData; + fn index(&self, index: SysrootCrate) -> &SysrootCrateData { + &self.crates[index] + } +} + +impl Sysroot { + pub fn root(&self) -> &AbsPath { + &self.root + } + + pub fn public_deps(&self) -> impl Iterator<Item = (&'static str, SysrootCrate, bool)> + '_ { + // core is added as a dependency before std in order to + // mimic rustcs dependency order + ["core", "alloc", "std"] + .into_iter() + .zip(iter::repeat(true)) + .chain(iter::once(("test", false))) + .filter_map(move |(name, prelude)| Some((name, self.by_name(name)?, prelude))) + } + + pub fn proc_macro(&self) -> Option<SysrootCrate> { + self.by_name("proc_macro") + } + + pub fn crates<'a>(&'a self) -> impl Iterator<Item = SysrootCrate> + ExactSizeIterator + 'a { + self.crates.iter().map(|(id, _data)| id) + } + + pub fn discover(dir: &AbsPath) -> Result<Sysroot> { + tracing::debug!("Discovering sysroot for {}", dir.display()); + let sysroot_dir = discover_sysroot_dir(dir)?; + let sysroot_src_dir = discover_sysroot_src_dir(&sysroot_dir, dir)?; + let res = Sysroot::load(sysroot_src_dir)?; + Ok(res) + } + + pub fn discover_rustc(cargo_toml: &ManifestPath) -> Option<ManifestPath> { + tracing::debug!("Discovering rustc source for {}", cargo_toml.display()); + let current_dir = cargo_toml.parent(); + discover_sysroot_dir(current_dir).ok().and_then(|sysroot_dir| get_rustc_src(&sysroot_dir)) + } + + pub fn load(sysroot_src_dir: AbsPathBuf) -> Result<Sysroot> { + let mut sysroot = Sysroot { root: sysroot_src_dir, crates: Arena::default() }; + + for path in SYSROOT_CRATES.trim().lines() { + let name = path.split('/').last().unwrap(); + let root = [format!("{}/src/lib.rs", path), format!("lib{}/lib.rs", path)] + .into_iter() + .map(|it| sysroot.root.join(it)) + .filter_map(|it| ManifestPath::try_from(it).ok()) + .find(|it| fs::metadata(it).is_ok()); + + if let Some(root) = root { + sysroot.crates.alloc(SysrootCrateData { + name: name.into(), + root, + deps: Vec::new(), + }); + } + } + + if let Some(std) = sysroot.by_name("std") { + for dep in STD_DEPS.trim().lines() { + if let Some(dep) = sysroot.by_name(dep) { + sysroot.crates[std].deps.push(dep) + } + } + } + + if let Some(alloc) = sysroot.by_name("alloc") { + if let Some(core) = sysroot.by_name("core") { + sysroot.crates[alloc].deps.push(core); + } + } + + if let Some(proc_macro) = sysroot.by_name("proc_macro") { + if let Some(std) = sysroot.by_name("std") { + sysroot.crates[proc_macro].deps.push(std); + } + } + + if sysroot.by_name("core").is_none() { + let var_note = if env::var_os("RUST_SRC_PATH").is_some() { + " (`RUST_SRC_PATH` might be incorrect, try unsetting it)" + } else { + "" + }; + anyhow::bail!( + "could not find libcore in sysroot path `{}`{}", + sysroot.root.as_path().display(), + var_note, + ); + } + + Ok(sysroot) + } + + fn by_name(&self, name: &str) -> Option<SysrootCrate> { + let (id, _data) = self.crates.iter().find(|(_id, data)| data.name == name)?; + Some(id) + } +} + +fn discover_sysroot_dir(current_dir: &AbsPath) -> Result<AbsPathBuf> { + let mut rustc = Command::new(toolchain::rustc()); + rustc.current_dir(current_dir).args(&["--print", "sysroot"]); + tracing::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()))?; + let core = path.join("core"); + if fs::metadata(&core).is_ok() { + tracing::debug!("Discovered sysroot by RUST_SRC_PATH: {}", path.display()); + return Ok(path); + } + tracing::debug!("RUST_SRC_PATH is set, but is invalid (no core: {:?}), ignoring", core); + } + + get_rust_src(sysroot_path) + .or_else(|| { + let mut rustup = Command::new(toolchain::rustup()); + rustup.current_dir(current_dir).args(&["component", "add", "rust-src"]); + utf8_stdout(rustup).ok()?; + get_rust_src(sysroot_path) + }) + .ok_or_else(|| { + format_err!( + "\ +can't load standard library from sysroot +{} +(discovered via `rustc --print sysroot`) +try installing the Rust source the same way you installed rustc", + sysroot_path.display(), + ) + }) +} + +fn get_rustc_src(sysroot_path: &AbsPath) -> Option<ManifestPath> { + let rustc_src = sysroot_path.join("lib/rustlib/rustc-src/rust/compiler/rustc/Cargo.toml"); + let rustc_src = ManifestPath::try_from(rustc_src).ok()?; + tracing::debug!("Checking for rustc source code: {}", rustc_src.display()); + if fs::metadata(&rustc_src).is_ok() { + Some(rustc_src) + } else { + None + } +} + +fn get_rust_src(sysroot_path: &AbsPath) -> Option<AbsPathBuf> { + let rust_src = sysroot_path.join("lib/rustlib/src/rust/library"); + tracing::debug!("Checking sysroot: {}", rust_src.display()); + if fs::metadata(&rust_src).is_ok() { + Some(rust_src) + } else { + None + } +} + +const SYSROOT_CRATES: &str = " +alloc +core +panic_abort +panic_unwind +proc_macro +profiler_builtins +std +stdarch/crates/std_detect +term +test +unwind"; + +const STD_DEPS: &str = " +alloc +core +panic_abort +panic_unwind +profiler_builtins +std_detect +term +test +unwind"; |