language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-11-01 12:24:29 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Rename sysroot src/lib related things

Browse source
This commit is contained in:
Lukas Wirth 2025-02-12 16:32:11 +01:00
parent 8a8ff99273
commit 172a504b56
6 changed files with 121 additions and 104 deletions
Download patch file Download diff file Expand all files Collapse all files

10
crates/project-model/src/lib.rs
View file

@ -260,19 +260,19 @@ fn parse_cfg(s: &str) -> Result<cfg::CfgAtom, String> {
} }
#[derive(Clone, Debug, PartialEq, Eq)] #[derive(Clone, Debug, PartialEq, Eq)]
pub enum SysrootSourceWorkspaceConfig { pub enum RustSourceWorkspaceConfig {
CargoMetadata(CargoMetadataConfig), CargoMetadata(CargoMetadataConfig),
Stitched, Stitched,
} }
impl Default for SysrootSourceWorkspaceConfig { impl Default for RustSourceWorkspaceConfig {
fn default() -> Self { fn default() -> Self {
SysrootSourceWorkspaceConfig::default_cargo() RustSourceWorkspaceConfig::default_cargo()
} }
} }
impl SysrootSourceWorkspaceConfig { impl RustSourceWorkspaceConfig {
pub fn default_cargo() -> Self { pub fn default_cargo() -> Self {
SysrootSourceWorkspaceConfig::CargoMetadata(Default::default()) RustSourceWorkspaceConfig::CargoMetadata(Default::default())
} }
} }

158
crates/project-model/src/sysroot.rs
View file

@ -22,19 +22,19 @@ use toolchain::{probe_for_binary, Tool};
use crate::{ use crate::{
cargo_workspace::CargoMetadataConfig, utf8_stdout, CargoWorkspace, ManifestPath, cargo_workspace::CargoMetadataConfig, utf8_stdout, CargoWorkspace, ManifestPath,
SysrootSourceWorkspaceConfig, RustSourceWorkspaceConfig,
}; };
#[derive(Debug, Clone, PartialEq, Eq)] #[derive(Debug, Clone, PartialEq, Eq)]
pub struct Sysroot { pub struct Sysroot {
root: Option<AbsPathBuf>, root: Option<AbsPathBuf>,
src_root: Option<AbsPathBuf>, rust_lib_src_root: Option<AbsPathBuf>,
workspace: SysrootWorkspace, workspace: RustLibSrcWorkspace,
error: Option<String>, error: Option<String>,
} }
#[derive(Debug, Clone, Eq, PartialEq)] #[derive(Debug, Clone, Eq, PartialEq)]
pub enum SysrootWorkspace { pub enum RustLibSrcWorkspace {
Workspace(CargoWorkspace), Workspace(CargoWorkspace),
Stitched(Stitched), Stitched(Stitched),
Empty, Empty,
@ -42,18 +42,20 @@ pub enum SysrootWorkspace {
#[derive(Debug, Clone, Eq, PartialEq)] #[derive(Debug, Clone, Eq, PartialEq)]
pub struct Stitched { pub struct Stitched {
crates: Arena<SysrootCrateData>, crates: Arena<RustLibSrcCrateData>,
} }
impl ops::Index<SysrootCrate> for Stitched { impl ops::Index<RustLibSrcCrate> for Stitched {
type Output = SysrootCrateData; type Output = RustLibSrcCrateData;
fn index(&self, index: SysrootCrate) -> &SysrootCrateData { fn index(&self, index: RustLibSrcCrate) -> &RustLibSrcCrateData {
&self.crates[index] &self.crates[index]
} }
} }
impl Stitched { impl Stitched {
pub(crate) fn public_deps(&self) -> impl Iterator<Item = (CrateName, SysrootCrate, bool)> + '_ { pub(crate) fn public_deps(
&self,
) -> impl Iterator<Item = (CrateName, RustLibSrcCrate, bool)> + '_ {
// core is added as a dependency before std in order to // core is added as a dependency before std in order to
// mimic rustcs dependency order // mimic rustcs dependency order
[("core", true), ("alloc", false), ("std", true), ("test", false)].into_iter().filter_map( [("core", true), ("alloc", false), ("std", true), ("test", false)].into_iter().filter_map(
@ -63,32 +65,37 @@ impl Stitched {
) )
} }
pub(crate) fn proc_macro(&self) -> Option<SysrootCrate> { pub(crate) fn proc_macro(&self) -> Option<RustLibSrcCrate> {
self.by_name("proc_macro") self.by_name("proc_macro")
} }
pub(crate) fn crates(&self) -> impl ExactSizeIterator<Item = SysrootCrate> + '_ { pub(crate) fn crates(&self) -> impl ExactSizeIterator<Item = RustLibSrcCrate> + '_ {
self.crates.iter().map(|(id, _data)| id) self.crates.iter().map(|(id, _data)| id)
} }
fn by_name(&self, name: &str) -> Option<SysrootCrate> { fn by_name(&self, name: &str) -> Option<RustLibSrcCrate> {
let (id, _data) = self.crates.iter().find(|(_id, data)| data.name == name)?; let (id, _data) = self.crates.iter().find(|(_id, data)| data.name == name)?;
Some(id) Some(id)
} }
} }
pub(crate) type SysrootCrate = Idx<SysrootCrateData>; pub(crate) type RustLibSrcCrate = Idx<RustLibSrcCrateData>;
#[derive(Debug, Clone, Eq, PartialEq)] #[derive(Debug, Clone, Eq, PartialEq)]
pub(crate) struct SysrootCrateData { pub(crate) struct RustLibSrcCrateData {
pub(crate) name: String, pub(crate) name: String,
pub(crate) root: ManifestPath, pub(crate) root: ManifestPath,
pub(crate) deps: Vec<SysrootCrate>, pub(crate) deps: Vec<RustLibSrcCrate>,
} }
impl Sysroot { impl Sysroot {
pub const fn empty() -> Sysroot { pub const fn empty() -> Sysroot {
Sysroot { root: None, src_root: None, workspace: SysrootWorkspace::Empty, error: None } Sysroot {
root: None,
rust_lib_src_root: None,
workspace: RustLibSrcWorkspace::Empty,
error: None,
}
} }
/// Returns sysroot "root" directory, where `bin/`, `etc/`, `lib/`, `libexec/` /// Returns sysroot "root" directory, where `bin/`, `etc/`, `lib/`, `libexec/`
@ -100,15 +107,15 @@ impl Sysroot {
/// Returns the sysroot "source" directory, where stdlib sources are located, like: /// 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` /// `$HOME/.rustup/toolchains/nightly-2022-07-23-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library`
pub fn src_root(&self) -> Option<&AbsPath> { pub fn rust_lib_src_root(&self) -> Option<&AbsPath> {
self.src_root.as_deref() self.rust_lib_src_root.as_deref()
} }
pub fn is_empty(&self) -> bool { pub fn is_rust_lib_src_empty(&self) -> bool {
match &self.workspace { match &self.workspace {
SysrootWorkspace::Workspace(ws) => ws.packages().next().is_none(), RustLibSrcWorkspace::Workspace(ws) => ws.packages().next().is_none(),
SysrootWorkspace::Stitched(stitched) => stitched.crates.is_empty(), RustLibSrcWorkspace::Stitched(stitched) => stitched.crates.is_empty(),
SysrootWorkspace::Empty => true, RustLibSrcWorkspace::Empty => true,
} }
} }
@ -118,13 +125,13 @@ impl Sysroot {
pub fn num_packages(&self) -> usize { pub fn num_packages(&self) -> usize {
match &self.workspace { match &self.workspace {
SysrootWorkspace::Workspace(ws) => ws.packages().count(), RustLibSrcWorkspace::Workspace(ws) => ws.packages().count(),
SysrootWorkspace::Stitched(c) => c.crates().count(), RustLibSrcWorkspace::Stitched(c) => c.crates().count(),
SysrootWorkspace::Empty => 0, RustLibSrcWorkspace::Empty => 0,
} }
} }
pub(crate) fn workspace(&self) -> &SysrootWorkspace { pub(crate) fn workspace(&self) -> &RustLibSrcWorkspace {
&self.workspace &self.workspace
} }
} }
@ -133,33 +140,33 @@ impl Sysroot {
/// Attempts to discover the toolchain's sysroot from the given `dir`. /// Attempts to discover the toolchain's sysroot from the given `dir`.
pub fn discover(dir: &AbsPath, extra_env: &FxHashMap<String, String>) -> Sysroot { pub fn discover(dir: &AbsPath, extra_env: &FxHashMap<String, String>) -> Sysroot {
let sysroot_dir = discover_sysroot_dir(dir, extra_env); let sysroot_dir = discover_sysroot_dir(dir, extra_env);
let sysroot_src_dir = sysroot_dir.as_ref().ok().map(|sysroot_dir| { let rust_lib_src_dir = sysroot_dir.as_ref().ok().map(|sysroot_dir| {
discover_sysroot_src_dir_or_add_component(sysroot_dir, dir, extra_env) discover_rust_lib_src_dir_or_add_component(sysroot_dir, dir, extra_env)
}); });
Sysroot::assemble(Some(sysroot_dir), sysroot_src_dir) Sysroot::assemble(Some(sysroot_dir), rust_lib_src_dir)
} }
pub fn discover_with_src_override( pub fn discover_with_src_override(
current_dir: &AbsPath, current_dir: &AbsPath,
extra_env: &FxHashMap<String, String>, extra_env: &FxHashMap<String, String>,
sysroot_src_dir: AbsPathBuf, rust_lib_src_dir: AbsPathBuf,
) -> Sysroot { ) -> Sysroot {
let sysroot_dir = discover_sysroot_dir(current_dir, extra_env); let sysroot_dir = discover_sysroot_dir(current_dir, extra_env);
Sysroot::assemble(Some(sysroot_dir), Some(Ok(sysroot_src_dir))) Sysroot::assemble(Some(sysroot_dir), Some(Ok(rust_lib_src_dir)))
} }
pub fn discover_sysroot_src_dir(sysroot_dir: AbsPathBuf) -> Sysroot { pub fn discover_rust_lib_src_dir(sysroot_dir: AbsPathBuf) -> Sysroot {
let sysroot_src_dir = discover_sysroot_src_dir(&sysroot_dir) let rust_lib_src_dir = discover_rust_lib_src_dir(&sysroot_dir)
.ok_or_else(|| format_err!("can't find standard library sources in {sysroot_dir}")); .ok_or_else(|| format_err!("can't find standard library sources in {sysroot_dir}"));
Sysroot::assemble(Some(Ok(sysroot_dir)), Some(sysroot_src_dir)) Sysroot::assemble(Some(Ok(sysroot_dir)), Some(rust_lib_src_dir))
} }
pub fn discover_rustc_src(&self) -> Option<ManifestPath> { pub fn discover_rustc_src(&self) -> Option<ManifestPath> {
get_rustc_src(self.root()?) get_rustc_src(self.root()?)
} }
pub fn new(sysroot_dir: Option<AbsPathBuf>, sysroot_src_dir: Option<AbsPathBuf>) -> Sysroot { pub fn new(sysroot_dir: Option<AbsPathBuf>, rust_lib_src_dir: Option<AbsPathBuf>) -> Sysroot {
Self::assemble(sysroot_dir.map(Ok), sysroot_src_dir.map(Ok)) Self::assemble(sysroot_dir.map(Ok), rust_lib_src_dir.map(Ok))
} }
/// Returns a command to run a tool preferring the cargo proxies if the sysroot exists. /// Returns a command to run a tool preferring the cargo proxies if the sysroot exists.
@ -200,7 +207,7 @@ impl Sysroot {
fn assemble( fn assemble(
sysroot_dir: Option<Result<AbsPathBuf, anyhow::Error>>, sysroot_dir: Option<Result<AbsPathBuf, anyhow::Error>>,
sysroot_src_dir: Option<Result<AbsPathBuf, anyhow::Error>>, rust_lib_src_dir: Option<Result<AbsPathBuf, anyhow::Error>>,
) -> Sysroot { ) -> Sysroot {
let mut errors = String::new(); let mut errors = String::new();
let root = match sysroot_dir { let root = match sysroot_dir {
@ -211,8 +218,8 @@ impl Sysroot {
} }
None => None, None => None,
}; };
let src_root = match sysroot_src_dir { let rust_lib_src_root = match rust_lib_src_dir {
Some(Ok(sysroot_src_dir)) => Some(sysroot_src_dir), Some(Ok(rust_lib_src_dir)) => Some(rust_lib_src_dir),
Some(Err(e)) => { Some(Err(e)) => {
format_to!(errors, "{e}\n"); format_to!(errors, "{e}\n");
None None
@ -221,21 +228,22 @@ impl Sysroot {
}; };
Sysroot { Sysroot {
root, root,
src_root, rust_lib_src_root,
workspace: SysrootWorkspace::Empty, workspace: RustLibSrcWorkspace::Empty,
error: errors.is_empty().not().then_some(errors), error: errors.is_empty().not().then_some(errors),
} }
} }
pub fn load_workspace( pub fn load_workspace(
&self, &self,
sysroot_source_config: &SysrootSourceWorkspaceConfig, sysroot_source_config: &RustSourceWorkspaceConfig,
) -> Option<SysrootWorkspace> { ) -> Option<RustLibSrcWorkspace> {
assert!(matches!(self.workspace, SysrootWorkspace::Empty), "workspace already loaded"); assert!(matches!(self.workspace, RustLibSrcWorkspace::Empty), "workspace already loaded");
let Self { root: _, src_root: Some(src_root), workspace: _, error: _ } = self else { let Self { root: _, rust_lib_src_root: Some(src_root), workspace: _, error: _ } = self
else {
return None; return None;
}; };
if let SysrootSourceWorkspaceConfig::CargoMetadata(cargo_config) = sysroot_source_config { if let RustSourceWorkspaceConfig::CargoMetadata(cargo_config) = sysroot_source_config {
let library_manifest = ManifestPath::try_from(src_root.join("Cargo.toml")).unwrap(); let library_manifest = ManifestPath::try_from(src_root.join("Cargo.toml")).unwrap();
if fs::metadata(&library_manifest).is_ok() { if fs::metadata(&library_manifest).is_ok() {
if let Some(loaded) = if let Some(loaded) =
@ -258,7 +266,7 @@ impl Sysroot {
.find(|it| fs::metadata(it).is_ok()); .find(|it| fs::metadata(it).is_ok());
if let Some(root) = root { if let Some(root) = root {
stitched.crates.alloc(SysrootCrateData { stitched.crates.alloc(RustLibSrcCrateData {
name: name.into(), name: name.into(),
root, root,
deps: Vec::new(), deps: Vec::new(),
@ -289,21 +297,23 @@ impl Sysroot {
} }
} }
} }
Some(SysrootWorkspace::Stitched(stitched)) Some(RustLibSrcWorkspace::Stitched(stitched))
} }
pub fn set_workspace(&mut self, workspace: SysrootWorkspace) { pub fn set_workspace(&mut self, workspace: RustLibSrcWorkspace) {
self.workspace = workspace; self.workspace = workspace;
if self.error.is_none() { if self.error.is_none() {
if let Some(src_root) = &self.src_root { if let Some(src_root) = &self.rust_lib_src_root {
let has_core = match &self.workspace { let has_core = match &self.workspace {
SysrootWorkspace::Workspace(ws) => ws.packages().any(|p| ws[p].name == "core"), RustLibSrcWorkspace::Workspace(ws) => {
SysrootWorkspace::Stitched(stitched) => stitched.by_name("core").is_some(), ws.packages().any(|p| ws[p].name == "core")
SysrootWorkspace::Empty => true, }
RustLibSrcWorkspace::Stitched(stitched) => stitched.by_name("core").is_some(),
RustLibSrcWorkspace::Empty => true,
}; };
if !has_core { if !has_core {
let var_note = if env::var_os("RUST_SRC_PATH").is_some() { let var_note = if env::var_os("rust_lib_src_PATH").is_some() {
" (env var `RUST_SRC_PATH` is set and may be incorrect, try unsetting it)" " (env var `rust_lib_src_PATH` is set and may be incorrect, try unsetting it)"
} else { } else {
", try running `rustup component add rust-src` to possibly fix this" ", try running `rustup component add rust-src` to possibly fix this"
}; };
@ -317,9 +327,9 @@ impl Sysroot {
fn load_library_via_cargo( fn load_library_via_cargo(
library_manifest: ManifestPath, library_manifest: ManifestPath,
sysroot_src_dir: &AbsPathBuf, rust_lib_src_dir: &AbsPathBuf,
cargo_config: &CargoMetadataConfig, cargo_config: &CargoMetadataConfig,
) -> Option<SysrootWorkspace> { ) -> Option<RustLibSrcWorkspace> {
tracing::debug!("Loading library metadata: {library_manifest}"); tracing::debug!("Loading library metadata: {library_manifest}");
let mut cargo_config = cargo_config.clone(); let mut cargo_config = cargo_config.clone();
// the sysroot uses `public-dependency`, so we make cargo think it's a nightly // the sysroot uses `public-dependency`, so we make cargo think it's a nightly
@ -330,7 +340,7 @@ impl Sysroot {
let (mut res, _) = match CargoWorkspace::fetch_metadata( let (mut res, _) = match CargoWorkspace::fetch_metadata(
&library_manifest, &library_manifest,
sysroot_src_dir, rust_lib_src_dir,
&cargo_config, &cargo_config,
&Sysroot::empty(), &Sysroot::empty(),
// Make sure we never attempt to write to the sysroot // Make sure we never attempt to write to the sysroot
@ -394,7 +404,7 @@ impl Sysroot {
}); });
let cargo_workspace = CargoWorkspace::new(res, library_manifest, Default::default()); let cargo_workspace = CargoWorkspace::new(res, library_manifest, Default::default());
Some(SysrootWorkspace::Workspace(cargo_workspace)) Some(RustLibSrcWorkspace::Workspace(cargo_workspace))
} }
} }
@ -410,36 +420,38 @@ fn discover_sysroot_dir(
Ok(AbsPathBuf::assert(Utf8PathBuf::from(stdout))) Ok(AbsPathBuf::assert(Utf8PathBuf::from(stdout)))
} }
fn discover_sysroot_src_dir(sysroot_path: &AbsPathBuf) -> Option<AbsPathBuf> { fn discover_rust_lib_src_dir(sysroot_path: &AbsPathBuf) -> Option<AbsPathBuf> {
if let Ok(path) = env::var("RUST_SRC_PATH") { if let Ok(path) = env::var("rust_lib_src_PATH") {
if let Ok(path) = AbsPathBuf::try_from(path.as_str()) { if let Ok(path) = AbsPathBuf::try_from(path.as_str()) {
let core = path.join("core"); let core = path.join("core");
if fs::metadata(&core).is_ok() { if fs::metadata(&core).is_ok() {
tracing::debug!("Discovered sysroot by RUST_SRC_PATH: {path}"); tracing::debug!("Discovered sysroot by rust_lib_src_PATH: {path}");
return Some(path); return Some(path);
} }
tracing::debug!("RUST_SRC_PATH is set, but is invalid (no core: {core:?}), ignoring"); tracing::debug!(
"rust_lib_src_PATH is set, but is invalid (no core: {core:?}), ignoring"
);
} else { } else {
tracing::debug!("RUST_SRC_PATH is set, but is invalid, ignoring"); tracing::debug!("rust_lib_src_PATH is set, but is invalid, ignoring");
} }
} }
get_rust_src(sysroot_path) get_rust_lib_src(sysroot_path)
} }
fn discover_sysroot_src_dir_or_add_component( fn discover_rust_lib_src_dir_or_add_component(
sysroot_path: &AbsPathBuf, sysroot_path: &AbsPathBuf,
current_dir: &AbsPath, current_dir: &AbsPath,
extra_env: &FxHashMap<String, String>, extra_env: &FxHashMap<String, String>,
) -> Result<AbsPathBuf> { ) -> Result<AbsPathBuf> {
discover_sysroot_src_dir(sysroot_path) discover_rust_lib_src_dir(sysroot_path)
.or_else(|| { .or_else(|| {
let mut rustup = toolchain::command(Tool::Rustup.prefer_proxy(), current_dir); let mut rustup = toolchain::command(Tool::Rustup.prefer_proxy(), current_dir);
rustup.envs(extra_env); rustup.envs(extra_env);
rustup.args(["component", "add", "rust-src"]); rustup.args(["component", "add", "rust-src"]);
tracing::info!("adding rust-src component by {:?}", rustup); tracing::info!("adding rust-src component by {:?}", rustup);
utf8_stdout(&mut rustup).ok()?; utf8_stdout(&mut rustup).ok()?;
get_rust_src(sysroot_path) get_rust_lib_src(sysroot_path)
}) })
.ok_or_else(|| { .ok_or_else(|| {
tracing::error!(%sysroot_path, "can't load standard library, try installing `rust-src`"); tracing::error!(%sysroot_path, "can't load standard library, try installing `rust-src`");
@ -464,11 +476,11 @@ fn get_rustc_src(sysroot_path: &AbsPath) -> Option<ManifestPath> {
} }
} }
fn get_rust_src(sysroot_path: &AbsPath) -> Option<AbsPathBuf> { fn get_rust_lib_src(sysroot_path: &AbsPath) -> Option<AbsPathBuf> {
let rust_src = sysroot_path.join("lib/rustlib/src/rust/library"); let rust_lib_src = sysroot_path.join("lib/rustlib/src/rust/library");
tracing::debug!("checking sysroot library: {rust_src}"); tracing::debug!("checking sysroot library: {rust_lib_src}");
if fs::metadata(&rust_src).is_ok() { if fs::metadata(&rust_lib_src).is_ok() {
Some(rust_src) Some(rust_lib_src)
} else { } else {
None None
} }

12
crates/project-model/src/tests.rs
View file

@ -12,9 +12,9 @@ use span::FileId;
use triomphe::Arc; use triomphe::Arc;
use crate::{ use crate::{
sysroot::SysrootWorkspace, workspace::ProjectWorkspaceKind, CargoWorkspace, CfgOverrides, sysroot::RustLibSrcWorkspace, workspace::ProjectWorkspaceKind, CargoWorkspace, CfgOverrides,
ManifestPath, ProjectJson, ProjectJsonData, ProjectWorkspace, Sysroot, ManifestPath, ProjectJson, ProjectJsonData, ProjectWorkspace, RustSourceWorkspaceConfig,
SysrootSourceWorkspaceConfig, WorkspaceBuildScripts, Sysroot, WorkspaceBuildScripts,
}; };
fn load_cargo(file: &str) -> (CrateGraph, ProcMacroPaths) { fn load_cargo(file: &str) -> (CrateGraph, ProcMacroPaths) {
@ -125,7 +125,7 @@ fn get_fake_sysroot() -> Sysroot {
let sysroot_dir = AbsPathBuf::assert(sysroot_path); let sysroot_dir = AbsPathBuf::assert(sysroot_path);
let sysroot_src_dir = sysroot_dir.clone(); let sysroot_src_dir = sysroot_dir.clone();
let mut sysroot = Sysroot::new(Some(sysroot_dir), Some(sysroot_src_dir)); let mut sysroot = Sysroot::new(Some(sysroot_dir), Some(sysroot_src_dir));
let loaded_sysroot = sysroot.load_workspace(&SysrootSourceWorkspaceConfig::default_cargo()); let loaded_sysroot = sysroot.load_workspace(&RustSourceWorkspaceConfig::default_cargo());
if let Some(loaded_sysroot) = loaded_sysroot { if let Some(loaded_sysroot) = loaded_sysroot {
sysroot.set_workspace(loaded_sysroot); sysroot.set_workspace(loaded_sysroot);
} }
@ -274,11 +274,11 @@ fn smoke_test_real_sysroot_cargo() {
AbsPath::assert(Utf8Path::new(env!("CARGO_MANIFEST_DIR"))), AbsPath::assert(Utf8Path::new(env!("CARGO_MANIFEST_DIR"))),
&Default::default(), &Default::default(),
); );
let loaded_sysroot = sysroot.load_workspace(&SysrootSourceWorkspaceConfig::default_cargo()); let loaded_sysroot = sysroot.load_workspace(&RustSourceWorkspaceConfig::default_cargo());
if let Some(loaded_sysroot) = loaded_sysroot { if let Some(loaded_sysroot) = loaded_sysroot {
sysroot.set_workspace(loaded_sysroot); sysroot.set_workspace(loaded_sysroot);
} }
assert!(matches!(sysroot.workspace(), SysrootWorkspace::Workspace(_))); assert!(matches!(sysroot.workspace(), RustLibSrcWorkspace::Workspace(_)));
let project_workspace = ProjectWorkspace { let project_workspace = ProjectWorkspace {
kind: ProjectWorkspaceKind::Cargo { kind: ProjectWorkspaceKind::Cargo {
cargo: cargo_workspace, cargo: cargo_workspace,

37
crates/project-model/src/workspace.rs
View file

@ -23,10 +23,10 @@ use crate::{
cargo_workspace::{CargoMetadataConfig, DepKind, PackageData, RustLibSource}, cargo_workspace::{CargoMetadataConfig, DepKind, PackageData, RustLibSource},
env::{cargo_config_env, inject_cargo_env, inject_cargo_package_env, inject_rustc_tool_env}, env::{cargo_config_env, inject_cargo_env, inject_cargo_package_env, inject_rustc_tool_env},
project_json::{Crate, CrateArrayIdx}, project_json::{Crate, CrateArrayIdx},
sysroot::{SysrootCrate, SysrootWorkspace}, sysroot::{RustLibSrcCrate, RustLibSrcWorkspace},
toolchain_info::{rustc_cfg, target_data_layout, target_tuple, version, QueryConfig}, toolchain_info::{rustc_cfg, target_data_layout, target_tuple, version, QueryConfig},
CargoConfig, CargoWorkspace, CfgOverrides, InvocationStrategy, ManifestPath, Package, CargoConfig, CargoWorkspace, CfgOverrides, InvocationStrategy, ManifestPath, Package,
ProjectJson, ProjectManifest, Sysroot, SysrootSourceWorkspaceConfig, TargetData, TargetKind, ProjectJson, ProjectManifest, RustSourceWorkspaceConfig, Sysroot, TargetData, TargetKind,
WorkspaceBuildScripts, WorkspaceBuildScripts,
}; };
use tracing::{debug, error, info}; use tracing::{debug, error, info};
@ -230,7 +230,7 @@ impl ProjectWorkspace {
) )
} }
(Some(RustLibSource::Path(path)), None) => { (Some(RustLibSource::Path(path)), None) => {
Sysroot::discover_sysroot_src_dir(path.clone()) Sysroot::discover_rust_lib_src_dir(path.clone())
} }
(Some(RustLibSource::Path(sysroot)), Some(sysroot_src)) => { (Some(RustLibSource::Path(sysroot)), Some(sysroot_src)) => {
Sysroot::new(Some(sysroot.clone()), Some(sysroot_src.clone())) Sysroot::new(Some(sysroot.clone()), Some(sysroot_src.clone()))
@ -238,7 +238,7 @@ impl ProjectWorkspace {
(None, _) => Sysroot::empty(), (None, _) => Sysroot::empty(),
}; };
tracing::info!(workspace = %cargo_toml, src_root = ?sysroot.src_root(), root = ?sysroot.root(), "Using sysroot"); tracing::info!(workspace = %cargo_toml, src_root = ?sysroot.rust_lib_src_root(), root = ?sysroot.root(), "Using sysroot");
progress("Querying project metadata".to_owned()); progress("Querying project metadata".to_owned());
let toolchain_config = QueryConfig::Cargo(&sysroot, cargo_toml); let toolchain_config = QueryConfig::Cargo(&sysroot, cargo_toml);
let targets = let targets =
@ -340,7 +340,7 @@ impl ProjectWorkspace {
) )
}); });
let loaded_sysroot = s.spawn(|| { let loaded_sysroot = s.spawn(|| {
sysroot.load_workspace(&SysrootSourceWorkspaceConfig::CargoMetadata( sysroot.load_workspace(&RustSourceWorkspaceConfig::CargoMetadata(
sysroot_metadata_config(extra_env, &targets), sysroot_metadata_config(extra_env, &targets),
)) ))
}); });
@ -405,12 +405,12 @@ impl ProjectWorkspace {
progress("Discovering sysroot".to_owned()); progress("Discovering sysroot".to_owned());
let mut sysroot = let mut sysroot =
Sysroot::new(project_json.sysroot.clone(), project_json.sysroot_src.clone()); Sysroot::new(project_json.sysroot.clone(), project_json.sysroot_src.clone());
let loaded_sysroot = sysroot.load_workspace(&SysrootSourceWorkspaceConfig::Stitched); let loaded_sysroot = sysroot.load_workspace(&RustSourceWorkspaceConfig::Stitched);
if let Some(loaded_sysroot) = loaded_sysroot { if let Some(loaded_sysroot) = loaded_sysroot {
sysroot.set_workspace(loaded_sysroot); sysroot.set_workspace(loaded_sysroot);
} }
tracing::info!(workspace = %project_json.manifest_or_root(), src_root = ?sysroot.src_root(), root = ?sysroot.root(), "Using sysroot"); tracing::info!(workspace = %project_json.manifest_or_root(), src_root = ?sysroot.rust_lib_src_root(), root = ?sysroot.root(), "Using sysroot");
progress("Querying project metadata".to_owned()); progress("Querying project metadata".to_owned());
let query_config = QueryConfig::Rustc(&sysroot, project_json.path().as_ref()); let query_config = QueryConfig::Rustc(&sysroot, project_json.path().as_ref());
let targets = target_tuple::get(query_config, config.target.as_deref(), &config.extra_env) let targets = target_tuple::get(query_config, config.target.as_deref(), &config.extra_env)
@ -458,7 +458,7 @@ impl ProjectWorkspace {
) -> anyhow::Result<ProjectWorkspace> { ) -> anyhow::Result<ProjectWorkspace> {
let dir = detached_file.parent(); let dir = detached_file.parent();
let mut sysroot = match &config.sysroot { let mut sysroot = match &config.sysroot {
Some(RustLibSource::Path(path)) => Sysroot::discover_sysroot_src_dir(path.clone()), Some(RustLibSource::Path(path)) => Sysroot::discover_rust_lib_src_dir(path.clone()),
Some(RustLibSource::Discover) => Sysroot::discover(dir, &config.extra_env), Some(RustLibSource::Discover) => Sysroot::discover(dir, &config.extra_env),
None => Sysroot::empty(), None => Sysroot::empty(),
}; };
@ -469,7 +469,7 @@ impl ProjectWorkspace {
.unwrap_or_default(); .unwrap_or_default();
let rustc_cfg = rustc_cfg::get(query_config, None, &config.extra_env); let rustc_cfg = rustc_cfg::get(query_config, None, &config.extra_env);
let data_layout = target_data_layout::get(query_config, None, &config.extra_env); let data_layout = target_data_layout::get(query_config, None, &config.extra_env);
let loaded_sysroot = sysroot.load_workspace(&SysrootSourceWorkspaceConfig::CargoMetadata( let loaded_sysroot = sysroot.load_workspace(&RustSourceWorkspaceConfig::CargoMetadata(
sysroot_metadata_config(&config.extra_env, &targets), sysroot_metadata_config(&config.extra_env, &targets),
)); ));
if let Some(loaded_sysroot) = loaded_sysroot { if let Some(loaded_sysroot) = loaded_sysroot {
@ -643,7 +643,7 @@ impl ProjectWorkspace {
pub fn to_roots(&self) -> Vec<PackageRoot> { pub fn to_roots(&self) -> Vec<PackageRoot> {
let mk_sysroot = || { let mk_sysroot = || {
let mut r = match self.sysroot.workspace() { let mut r = match self.sysroot.workspace() {
SysrootWorkspace::Workspace(ws) => ws RustLibSrcWorkspace::Workspace(ws) => ws
.packages() .packages()
.filter_map(|pkg| { .filter_map(|pkg| {
if ws[pkg].is_local { if ws[pkg].is_local {
@ -664,12 +664,17 @@ impl ProjectWorkspace {
Some(PackageRoot { is_local: false, include, exclude }) Some(PackageRoot { is_local: false, include, exclude })
}) })
.collect(), .collect(),
SysrootWorkspace::Stitched(_) | SysrootWorkspace::Empty => vec![], RustLibSrcWorkspace::Stitched(_) | RustLibSrcWorkspace::Empty => vec![],
}; };
r.push(PackageRoot { r.push(PackageRoot {
is_local: false, is_local: false,
include: self.sysroot.src_root().map(|it| it.to_path_buf()).into_iter().collect(), include: self
.sysroot
.rust_lib_src_root()
.map(|it| it.to_path_buf())
.into_iter()
.collect(),
exclude: Vec::new(), exclude: Vec::new(),
}); });
r r
@ -1483,7 +1488,7 @@ fn sysroot_to_crate_graph(
) -> (SysrootPublicDeps, Option<CrateId>) { ) -> (SysrootPublicDeps, Option<CrateId>) {
let _p = tracing::info_span!("sysroot_to_crate_graph").entered(); let _p = tracing::info_span!("sysroot_to_crate_graph").entered();
match sysroot.workspace() { match sysroot.workspace() {
SysrootWorkspace::Workspace(cargo) => { RustLibSrcWorkspace::Workspace(cargo) => {
let (mut cg, mut pm) = cargo_to_crate_graph( let (mut cg, mut pm) = cargo_to_crate_graph(
load, load,
None, None,
@ -1558,7 +1563,7 @@ fn sysroot_to_crate_graph(
(SysrootPublicDeps { deps: pub_deps }, libproc_macro) (SysrootPublicDeps { deps: pub_deps }, libproc_macro)
} }
SysrootWorkspace::Stitched(stitched) => { RustLibSrcWorkspace::Stitched(stitched) => {
let cfg_options = Arc::new({ let cfg_options = Arc::new({
let mut cfg_options = CfgOptions::default(); let mut cfg_options = CfgOptions::default();
cfg_options.extend(rustc_cfg); cfg_options.extend(rustc_cfg);
@ -1566,7 +1571,7 @@ fn sysroot_to_crate_graph(
cfg_options.insert_atom(sym::miri.clone()); cfg_options.insert_atom(sym::miri.clone());
cfg_options cfg_options
}); });
let sysroot_crates: FxHashMap<SysrootCrate, CrateId> = stitched let sysroot_crates: FxHashMap<RustLibSrcCrate, CrateId> = stitched
.crates() .crates()
.filter_map(|krate| { .filter_map(|krate| {
let file_id = load(&stitched[krate].root)?; let file_id = load(&stitched[krate].root)?;
@ -1611,7 +1616,7 @@ fn sysroot_to_crate_graph(
stitched.proc_macro().and_then(|it| sysroot_crates.get(&it).copied()); stitched.proc_macro().and_then(|it| sysroot_crates.get(&it).copied());
(public_deps, libproc_macro) (public_deps, libproc_macro)
} }
SysrootWorkspace::Empty => (SysrootPublicDeps { deps: vec![] }, None), RustLibSrcWorkspace::Empty => (SysrootPublicDeps { deps: vec![] }, None),
} }
} }

6
crates/rust-analyzer/src/cli/rustc_tests.rs
View file

@ -12,8 +12,8 @@ use paths::Utf8PathBuf;
use profile::StopWatch; use profile::StopWatch;
use project_model::toolchain_info::{target_data_layout, QueryConfig}; use project_model::toolchain_info::{target_data_layout, QueryConfig};
use project_model::{ use project_model::{
CargoConfig, ManifestPath, ProjectWorkspace, ProjectWorkspaceKind, RustLibSource, Sysroot, CargoConfig, ManifestPath, ProjectWorkspace, ProjectWorkspaceKind, RustLibSource,
SysrootSourceWorkspaceConfig, RustSourceWorkspaceConfig, Sysroot,
}; };
use load_cargo::{load_workspace, LoadCargoConfig, ProcMacroServerChoice}; use load_cargo::{load_workspace, LoadCargoConfig, ProcMacroServerChoice};
@ -75,7 +75,7 @@ impl Tester {
}; };
let mut sysroot = Sysroot::discover(tmp_file.parent().unwrap(), &cargo_config.extra_env); let mut sysroot = Sysroot::discover(tmp_file.parent().unwrap(), &cargo_config.extra_env);
let loaded_sysroot = sysroot.load_workspace(&SysrootSourceWorkspaceConfig::default_cargo()); let loaded_sysroot = sysroot.load_workspace(&RustSourceWorkspaceConfig::default_cargo());
if let Some(loaded_sysroot) = loaded_sysroot { if let Some(loaded_sysroot) = loaded_sysroot {
sysroot.set_workspace(loaded_sysroot); sysroot.set_workspace(loaded_sysroot);
} }

2
crates/rust-analyzer/tests/slow-tests/main.rs
View file

@ -1153,7 +1153,7 @@ fn resolve_proc_macro() {
&Default::default(), &Default::default(),
); );
let loaded_sysroot = let loaded_sysroot =
sysroot.load_workspace(&project_model::SysrootSourceWorkspaceConfig::default_cargo()); sysroot.load_workspace(&project_model::RustSourceWorkspaceConfig::default_cargo());
if let Some(loaded_sysroot) = loaded_sysroot { if let Some(loaded_sysroot) = loaded_sysroot {
sysroot.set_workspace(loaded_sysroot); sysroot.set_workspace(loaded_sysroot);
} }