rust/crates/project-model/src/sysroot.rs

238 lines
7.6 KiB
Rust
Raw Normal View History

//! 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.
2021-10-21 10:49:28 -05:00
use std::{env, fs, iter, ops, path::PathBuf, process::Command};
2019-01-10 13:21:14 -06:00
use anyhow::{format_err, Result};
2021-01-14 09:47:42 -06:00
use la_arena::{Arena, Idx};
use paths::{AbsPath, AbsPathBuf};
2020-05-08 07:54:29 -05:00
2022-08-18 16:41:17 -05:00
use crate::{utf8_stdout, CargoConfig, ManifestPath};
2019-01-10 13:21:14 -06:00
#[derive(Debug, Clone, Eq, PartialEq)]
2019-01-10 13:21:14 -06:00
pub struct Sysroot {
root: AbsPathBuf,
src_root: AbsPathBuf,
2020-03-19 10:00:11 -05:00
crates: Arena<SysrootCrateData>,
2019-01-10 13:47:05 -06:00
}
2020-11-02 09:31:38 -06:00
pub(crate) type SysrootCrate = Idx<SysrootCrateData>;
2019-01-10 13:47:05 -06:00
#[derive(Debug, Clone, Eq, PartialEq)]
2020-03-19 11:59:31 -05:00
pub struct SysrootCrateData {
pub name: String,
pub root: ManifestPath,
2020-03-19 11:59:31 -05:00
pub deps: Vec<SysrootCrate>,
}
impl ops::Index<SysrootCrate> for Sysroot {
type Output = SysrootCrateData;
fn index(&self, index: SysrootCrate) -> &SysrootCrateData {
&self.crates[index]
}
2019-01-10 13:21:14 -06:00
}
impl Sysroot {
2022-07-25 09:59:10 -05:00
/// Returns sysroot "root" directory, where `bin/`, `etc/`, `lib/`, `libexec/`
/// subfolder live, like:
/// `$HOME/.rustup/toolchains/nightly-2022-07-23-x86_64-unknown-linux-gnu`
pub fn root(&self) -> &AbsPath {
&self.root
}
2022-07-25 09:59:10 -05:00
/// Returns the sysroot "source" directory, where stdlib sources are located, like:
/// `$HOME/.rustup/toolchains/nightly-2022-07-23-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library`
pub fn src_root(&self) -> &AbsPath {
&self.src_root
}
2021-09-28 14:39:41 -05:00
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
2021-09-28 14:39:41 -05:00
["core", "alloc", "std"]
2021-11-03 07:21:46 -05:00
.into_iter()
2021-09-28 14:39:41 -05:00
.zip(iter::repeat(true))
.chain(iter::once(("test", false)))
.filter_map(move |(name, prelude)| Some((name, self.by_name(name)?, prelude)))
2019-01-10 14:05:22 -06:00
}
2019-11-24 04:33:12 -06:00
pub fn proc_macro(&self) -> Option<SysrootCrate> {
self.by_name("proc_macro")
}
2019-08-06 03:54:51 -05:00
pub fn crates<'a>(&'a self) -> impl Iterator<Item = SysrootCrate> + ExactSizeIterator + 'a {
2019-01-10 15:37:10 -06:00
self.crates.iter().map(|(id, _data)| id)
}
2022-08-18 16:41:17 -05:00
pub fn discover(dir: &AbsPath, config: &CargoConfig) -> Result<Sysroot> {
2021-08-15 07:46:13 -05:00
tracing::debug!("Discovering sysroot for {}", dir.display());
2022-08-18 16:41:17 -05:00
let sysroot_dir = discover_sysroot_dir(dir, config)?;
let sysroot_src_dir = discover_sysroot_src_dir(&sysroot_dir, dir, config)?;
let res = Sysroot::load(sysroot_dir, sysroot_src_dir)?;
Ok(res)
}
2022-08-18 16:41:17 -05:00
pub fn discover_rustc(cargo_toml: &ManifestPath, config: &CargoConfig) -> Option<ManifestPath> {
2021-08-15 07:46:13 -05:00
tracing::debug!("Discovering rustc source for {}", cargo_toml.display());
let current_dir = cargo_toml.parent();
2022-08-18 16:41:17 -05:00
discover_sysroot_dir(current_dir, config)
.ok()
.and_then(|sysroot_dir| get_rustc_src(&sysroot_dir))
}
pub fn load(sysroot_dir: AbsPathBuf, sysroot_src_dir: AbsPathBuf) -> Result<Sysroot> {
let mut sysroot =
Sysroot { root: sysroot_dir, src_root: sysroot_src_dir, crates: Arena::default() };
2021-06-21 08:26:26 -05:00
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)]
2021-11-03 07:21:46 -05:00
.into_iter()
.map(|it| sysroot.src_root.join(it))
.filter_map(|it| ManifestPath::try_from(it).ok())
2021-07-17 08:43:33 -05:00
.find(|it| fs::metadata(it).is_ok());
if let Some(root) = root {
2019-01-10 13:47:05 -06:00
sysroot.crates.alloc(SysrootCrateData {
name: name.into(),
2019-01-10 15:37:10 -06:00
root,
2019-01-10 13:47:05 -06:00
deps: Vec::new(),
});
}
}
if let Some(std) = sysroot.by_name("std") {
2019-01-10 13:47:05 -06:00
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") {
2019-06-13 14:59:50 -05:00
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.src_root.as_path().display(),
var_note,
);
}
Ok(sysroot)
2019-01-10 13:47:05 -06:00
}
2019-01-10 13:21:14 -06:00
2019-01-10 13:47:05 -06:00
fn by_name(&self, name: &str) -> Option<SysrootCrate> {
let (id, _data) = self.crates.iter().find(|(_id, data)| data.name == name)?;
Some(id)
2019-01-10 13:21:14 -06:00
}
}
2019-01-10 13:47:05 -06:00
2022-08-18 16:41:17 -05:00
fn discover_sysroot_dir(current_dir: &AbsPath, config: &CargoConfig) -> Result<AbsPathBuf> {
let mut rustc = Command::new(toolchain::rustc());
2022-08-18 16:41:17 -05:00
rustc.envs(&config.extra_env);
rustc.current_dir(current_dir).args(&["--print", "sysroot"]);
2021-08-15 07:46:13 -05:00
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,
2022-08-18 16:41:17 -05:00
config: &CargoConfig,
) -> Result<AbsPathBuf> {
2020-02-17 16:38:01 -06:00
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");
2021-07-17 08:43:33 -05:00
if fs::metadata(&core).is_ok() {
2021-08-15 07:46:13 -05:00
tracing::debug!("Discovered sysroot by RUST_SRC_PATH: {}", path.display());
return Ok(path);
}
2021-08-15 07:46:13 -05:00
tracing::debug!("RUST_SRC_PATH is set, but is invalid (no core: {:?}), ignoring", core);
2020-02-17 16:38:01 -06:00
}
2021-06-12 22:54:16 -05:00
get_rust_src(sysroot_path)
.or_else(|| {
let mut rustup = Command::new(toolchain::rustup());
2022-08-18 16:41:17 -05:00
rustup.envs(&config.extra_env);
rustup.current_dir(current_dir).args(&["component", "add", "rust-src"]);
utf8_stdout(rustup).ok()?;
2021-06-12 22:54:16 -05:00
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()?;
2021-08-15 07:46:13 -05:00
tracing::debug!("Checking for rustc source code: {}", rustc_src.display());
2021-07-17 08:43:33 -05:00
if fs::metadata(&rustc_src).is_ok() {
Some(rustc_src)
} else {
None
}
}
fn get_rust_src(sysroot_path: &AbsPath) -> Option<AbsPathBuf> {
2021-10-04 10:36:56 -05:00
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
}
2020-02-17 15:33:48 -06:00
}
2019-01-10 13:47:05 -06:00
const SYSROOT_CRATES: &str = "
alloc
2020-07-30 09:17:59 -05:00
core
2019-01-10 13:47:05 -06:00
panic_abort
2020-07-30 09:17:59 -05:00
panic_unwind
proc_macro
profiler_builtins
std
2021-06-21 08:26:26 -05:00
stdarch/crates/std_detect
2019-01-10 13:47:05 -06:00
term
2020-07-30 09:17:59 -05:00
test
unwind";
2019-01-10 13:47:05 -06:00
const STD_DEPS: &str = "
2019-02-03 16:23:59 -06:00
alloc
2019-02-03 09:35:42 -06:00
core
2019-01-10 13:47:05 -06:00
panic_abort
2020-07-30 09:17:59 -05:00
panic_unwind
profiler_builtins
2021-06-21 08:26:26 -05:00
std_detect
2020-07-30 09:17:59 -05:00
term
test
unwind";