bendns' repos / rust-analyzer
Unnamed repository; edit this file 'description' to name the repository.
Diffstat
-rw-r--r--crates/project-model/src/lib.rs10
-rw-r--r--crates/project-model/src/sysroot.rs169
-rw-r--r--crates/project-model/src/tests.rs18
-rw-r--r--crates/project-model/src/workspace.rs323
-rw-r--r--crates/rust-analyzer/src/cli/rustc_tests.rs10
-rw-r--r--crates/rust-analyzer/src/reload.rs1
-rw-r--r--crates/rust-analyzer/tests/slow-tests/main.rs6
7 files changed, 335 insertions, 202 deletions
diff --git a/crates/project-model/src/lib.rs b/crates/project-model/src/lib.rs
index fc1fd7b877..0c73447468 100644
--- a/crates/project-model/src/lib.rs
+++ b/crates/project-model/src/lib.rs
@@ -260,19 +260,19 @@ fn parse_cfg(s: &str) -> Result<cfg::CfgAtom, String> {
}
#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum SysrootSourceWorkspaceConfig {
+pub enum RustSourceWorkspaceConfig {
CargoMetadata(CargoMetadataConfig),
Stitched,
}
-impl Default for SysrootSourceWorkspaceConfig {
+impl Default for RustSourceWorkspaceConfig {
fn default() -> Self {
- SysrootSourceWorkspaceConfig::default_cargo()
+ RustSourceWorkspaceConfig::default_cargo()
}
}
-impl SysrootSourceWorkspaceConfig {
+impl RustSourceWorkspaceConfig {
pub fn default_cargo() -> Self {
- SysrootSourceWorkspaceConfig::CargoMetadata(Default::default())
+ RustSourceWorkspaceConfig::CargoMetadata(Default::default())
}
}
diff --git a/crates/project-model/src/sysroot.rs b/crates/project-model/src/sysroot.rs
index 8f633d24be..510c18dd14 100644
--- a/crates/project-model/src/sysroot.rs
+++ b/crates/project-model/src/sysroot.rs
@@ -22,38 +22,40 @@ use toolchain::{probe_for_binary, Tool};
use crate::{
cargo_workspace::CargoMetadataConfig, utf8_stdout, CargoWorkspace, ManifestPath,
- SysrootSourceWorkspaceConfig,
+ RustSourceWorkspaceConfig,
};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Sysroot {
root: Option<AbsPathBuf>,
- src_root: Option<AbsPathBuf>,
- workspace: SysrootWorkspace,
+ rust_lib_src_root: Option<AbsPathBuf>,
+ workspace: RustLibSrcWorkspace,
error: Option<String>,
}
#[derive(Debug, Clone, Eq, PartialEq)]
-pub(crate) enum SysrootWorkspace {
+pub enum RustLibSrcWorkspace {
Workspace(CargoWorkspace),
Stitched(Stitched),
Empty,
}
#[derive(Debug, Clone, Eq, PartialEq)]
-pub(crate) struct Stitched {
- crates: Arena<SysrootCrateData>,
+pub struct Stitched {
+ crates: Arena<RustLibSrcCrateData>,
}
-impl ops::Index<SysrootCrate> for Stitched {
- type Output = SysrootCrateData;
- fn index(&self, index: SysrootCrate) -> &SysrootCrateData {
+impl ops::Index<RustLibSrcCrate> for Stitched {
+ type Output = RustLibSrcCrateData;
+ fn index(&self, index: RustLibSrcCrate) -> &RustLibSrcCrateData {
&self.crates[index]
}
}
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
// mimic rustcs dependency order
[("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")
}
- 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)
}
- 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)?;
Some(id)
}
}
-pub(crate) type SysrootCrate = Idx<SysrootCrateData>;
+pub(crate) type RustLibSrcCrate = Idx<RustLibSrcCrateData>;
#[derive(Debug, Clone, Eq, PartialEq)]
-pub(crate) struct SysrootCrateData {
+pub(crate) struct RustLibSrcCrateData {
pub(crate) name: String,
pub(crate) root: ManifestPath,
- pub(crate) deps: Vec<SysrootCrate>,
+ pub(crate) deps: Vec<RustLibSrcCrate>,
}
impl 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/`
@@ -100,15 +107,15 @@ impl Sysroot {
/// 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) -> Option<&AbsPath> {
- self.src_root.as_deref()
+ pub fn rust_lib_src_root(&self) -> Option<&AbsPath> {
+ 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 {
- SysrootWorkspace::Workspace(ws) => ws.packages().next().is_none(),
- SysrootWorkspace::Stitched(stitched) => stitched.crates.is_empty(),
- SysrootWorkspace::Empty => true,
+ RustLibSrcWorkspace::Workspace(ws) => ws.packages().next().is_none(),
+ RustLibSrcWorkspace::Stitched(stitched) => stitched.crates.is_empty(),
+ RustLibSrcWorkspace::Empty => true,
}
}
@@ -118,13 +125,13 @@ impl Sysroot {
pub fn num_packages(&self) -> usize {
match &self.workspace {
- SysrootWorkspace::Workspace(ws) => ws.packages().count(),
- SysrootWorkspace::Stitched(c) => c.crates().count(),
- SysrootWorkspace::Empty => 0,
+ RustLibSrcWorkspace::Workspace(ws) => ws.packages().count(),
+ RustLibSrcWorkspace::Stitched(c) => c.crates().count(),
+ RustLibSrcWorkspace::Empty => 0,
}
}
- pub(crate) fn workspace(&self) -> &SysrootWorkspace {
+ pub(crate) fn workspace(&self) -> &RustLibSrcWorkspace {
&self.workspace
}
}
@@ -133,33 +140,33 @@ impl Sysroot {
/// Attempts to discover the toolchain's sysroot from the given `dir`.
pub fn discover(dir: &AbsPath, extra_env: &FxHashMap<String, String>) -> Sysroot {
let sysroot_dir = discover_sysroot_dir(dir, extra_env);
- let sysroot_src_dir = sysroot_dir.as_ref().ok().map(|sysroot_dir| {
- discover_sysroot_src_dir_or_add_component(sysroot_dir, dir, extra_env)
+ let rust_lib_src_dir = sysroot_dir.as_ref().ok().map(|sysroot_dir| {
+ 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(
current_dir: &AbsPath,
extra_env: &FxHashMap<String, String>,
- sysroot_src_dir: AbsPathBuf,
+ rust_lib_src_dir: AbsPathBuf,
) -> Sysroot {
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 {
- let sysroot_src_dir = discover_sysroot_src_dir(&sysroot_dir)
+ pub fn discover_rust_lib_src_dir(sysroot_dir: AbsPathBuf) -> Sysroot {
+ 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}"));
- 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> {
get_rustc_src(self.root()?)
}
- pub fn new(sysroot_dir: Option<AbsPathBuf>, sysroot_src_dir: Option<AbsPathBuf>) -> Sysroot {
- Self::assemble(sysroot_dir.map(Ok), sysroot_src_dir.map(Ok))
+ pub fn new(sysroot_dir: Option<AbsPathBuf>, rust_lib_src_dir: Option<AbsPathBuf>) -> Sysroot {
+ 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.
@@ -200,7 +207,7 @@ impl Sysroot {
fn assemble(
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 {
let mut errors = String::new();
let root = match sysroot_dir {
@@ -211,8 +218,8 @@ impl Sysroot {
}
None => None,
};
- let src_root = match sysroot_src_dir {
- Some(Ok(sysroot_src_dir)) => Some(sysroot_src_dir),
+ let rust_lib_src_root = match rust_lib_src_dir {
+ Some(Ok(rust_lib_src_dir)) => Some(rust_lib_src_dir),
Some(Err(e)) => {
format_to!(errors, "{e}\n");
None
@@ -221,24 +228,28 @@ impl Sysroot {
};
Sysroot {
root,
- src_root,
- workspace: SysrootWorkspace::Empty,
+ rust_lib_src_root,
+ workspace: RustLibSrcWorkspace::Empty,
error: errors.is_empty().not().then_some(errors),
}
}
- pub fn load_workspace(&mut self, sysroot_source_config: &SysrootSourceWorkspaceConfig) {
- assert!(matches!(self.workspace, SysrootWorkspace::Empty), "workspace already loaded");
- let Self { root: _, src_root: Some(src_root), workspace, error: _ } = self else { return };
- if let SysrootSourceWorkspaceConfig::CargoMetadata(cargo_config) = sysroot_source_config {
+ pub fn load_workspace(
+ &self,
+ sysroot_source_config: &RustSourceWorkspaceConfig,
+ ) -> Option<RustLibSrcWorkspace> {
+ assert!(matches!(self.workspace, RustLibSrcWorkspace::Empty), "workspace already loaded");
+ let Self { root: _, rust_lib_src_root: Some(src_root), workspace: _, error: _ } = self
+ else {
+ return None;
+ };
+ if let RustSourceWorkspaceConfig::CargoMetadata(cargo_config) = sysroot_source_config {
let library_manifest = ManifestPath::try_from(src_root.join("Cargo.toml")).unwrap();
if fs::metadata(&library_manifest).is_ok() {
if let Some(loaded) =
Self::load_library_via_cargo(library_manifest, src_root, cargo_config)
{
- *workspace = loaded;
- self.load_core_check();
- return;
+ return Some(loaded);
}
}
}
@@ -255,7 +266,7 @@ impl Sysroot {
.find(|it| fs::metadata(it).is_ok());
if let Some(root) = root {
- stitched.crates.alloc(SysrootCrateData {
+ stitched.crates.alloc(RustLibSrcCrateData {
name: name.into(),
root,
deps: Vec::new(),
@@ -286,21 +297,23 @@ impl Sysroot {
}
}
}
- *workspace = SysrootWorkspace::Stitched(stitched);
- self.load_core_check();
+ Some(RustLibSrcWorkspace::Stitched(stitched))
}
- fn load_core_check(&mut self) {
+ pub fn set_workspace(&mut self, workspace: RustLibSrcWorkspace) {
+ self.workspace = workspace;
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 {
- SysrootWorkspace::Workspace(ws) => ws.packages().any(|p| ws[p].name == "core"),
- SysrootWorkspace::Stitched(stitched) => stitched.by_name("core").is_some(),
- SysrootWorkspace::Empty => true,
+ RustLibSrcWorkspace::Workspace(ws) => {
+ ws.packages().any(|p| ws[p].name == "core")
+ }
+ RustLibSrcWorkspace::Stitched(stitched) => stitched.by_name("core").is_some(),
+ RustLibSrcWorkspace::Empty => true,
};
if !has_core {
- let var_note = if env::var_os("RUST_SRC_PATH").is_some() {
- " (env var `RUST_SRC_PATH` is set and may be incorrect, try unsetting it)"
+ let var_note = if env::var_os("rust_lib_src_PATH").is_some() {
+ " (env var `rust_lib_src_PATH` is set and may be incorrect, try unsetting it)"
} else {
", try running `rustup component add rust-src` to possibly fix this"
};
@@ -314,9 +327,9 @@ impl Sysroot {
fn load_library_via_cargo(
library_manifest: ManifestPath,
- sysroot_src_dir: &AbsPathBuf,
+ rust_lib_src_dir: &AbsPathBuf,
cargo_config: &CargoMetadataConfig,
- ) -> Option<SysrootWorkspace> {
+ ) -> Option<RustLibSrcWorkspace> {
tracing::debug!("Loading library metadata: {library_manifest}");
let mut cargo_config = cargo_config.clone();
// the sysroot uses `public-dependency`, so we make cargo think it's a nightly
@@ -327,7 +340,7 @@ impl Sysroot {
let (mut res, _) = match CargoWorkspace::fetch_metadata(
&library_manifest,
- sysroot_src_dir,
+ rust_lib_src_dir,
&cargo_config,
&Sysroot::empty(),
// Make sure we never attempt to write to the sysroot
@@ -391,7 +404,7 @@ impl Sysroot {
});
let cargo_workspace = CargoWorkspace::new(res, library_manifest, Default::default());
- Some(SysrootWorkspace::Workspace(cargo_workspace))
+ Some(RustLibSrcWorkspace::Workspace(cargo_workspace))
}
}
@@ -407,36 +420,38 @@ fn discover_sysroot_dir(
Ok(AbsPathBuf::assert(Utf8PathBuf::from(stdout)))
}
-fn discover_sysroot_src_dir(sysroot_path: &AbsPathBuf) -> Option<AbsPathBuf> {
- if let Ok(path) = env::var("RUST_SRC_PATH") {
+fn discover_rust_lib_src_dir(sysroot_path: &AbsPathBuf) -> Option<AbsPathBuf> {
+ if let Ok(path) = env::var("rust_lib_src_PATH") {
if let Ok(path) = AbsPathBuf::try_from(path.as_str()) {
let core = path.join("core");
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);
}
- 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 {
- 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,
current_dir: &AbsPath,
extra_env: &FxHashMap<String, String>,
) -> Result<AbsPathBuf> {
- discover_sysroot_src_dir(sysroot_path)
+ discover_rust_lib_src_dir(sysroot_path)
.or_else(|| {
let mut rustup = toolchain::command(Tool::Rustup.prefer_proxy(), current_dir);
rustup.envs(extra_env);
rustup.args(["component", "add", "rust-src"]);
tracing::info!("adding rust-src component by {:?}", rustup);
utf8_stdout(&mut rustup).ok()?;
- get_rust_src(sysroot_path)
+ get_rust_lib_src(sysroot_path)
})
.ok_or_else(|| {
tracing::error!(%sysroot_path, "can't load standard library, try installing `rust-src`");
@@ -461,11 +476,11 @@ fn get_rustc_src(sysroot_path: &AbsPath) -> Option<ManifestPath> {
}
}
-fn get_rust_src(sysroot_path: &AbsPath) -> Option<AbsPathBuf> {
- let rust_src = sysroot_path.join("lib/rustlib/src/rust/library");
- tracing::debug!("checking sysroot library: {rust_src}");
- if fs::metadata(&rust_src).is_ok() {
- Some(rust_src)
+fn get_rust_lib_src(sysroot_path: &AbsPath) -> Option<AbsPathBuf> {
+ let rust_lib_src = sysroot_path.join("lib/rustlib/src/rust/library");
+ tracing::debug!("checking sysroot library: {rust_lib_src}");
+ if fs::metadata(&rust_lib_src).is_ok() {
+ Some(rust_lib_src)
} else {
None
}
diff --git a/crates/project-model/src/tests.rs b/crates/project-model/src/tests.rs
index 2856086543..25e4368d95 100644
--- a/crates/project-model/src/tests.rs
+++ b/crates/project-model/src/tests.rs
@@ -12,9 +12,9 @@ use span::FileId;
use triomphe::Arc;
use crate::{
- sysroot::SysrootWorkspace, workspace::ProjectWorkspaceKind, CargoWorkspace, CfgOverrides,
- ManifestPath, ProjectJson, ProjectJsonData, ProjectWorkspace, Sysroot,
- SysrootSourceWorkspaceConfig, WorkspaceBuildScripts,
+ sysroot::RustLibSrcWorkspace, workspace::ProjectWorkspaceKind, CargoWorkspace, CfgOverrides,
+ ManifestPath, ProjectJson, ProjectJsonData, ProjectWorkspace, RustSourceWorkspaceConfig,
+ Sysroot, WorkspaceBuildScripts,
};
fn load_cargo(file: &str) -> (CrateGraph, ProcMacroPaths) {
@@ -125,7 +125,10 @@ fn get_fake_sysroot() -> Sysroot {
let sysroot_dir = AbsPathBuf::assert(sysroot_path);
let sysroot_src_dir = sysroot_dir.clone();
let mut sysroot = Sysroot::new(Some(sysroot_dir), Some(sysroot_src_dir));
- sysroot.load_workspace(&SysrootSourceWorkspaceConfig::default_cargo());
+ let loaded_sysroot = sysroot.load_workspace(&RustSourceWorkspaceConfig::default_cargo());
+ if let Some(loaded_sysroot) = loaded_sysroot {
+ sysroot.set_workspace(loaded_sysroot);
+ }
sysroot
}
@@ -271,8 +274,11 @@ fn smoke_test_real_sysroot_cargo() {
AbsPath::assert(Utf8Path::new(env!("CARGO_MANIFEST_DIR"))),
&Default::default(),
);
- sysroot.load_workspace(&SysrootSourceWorkspaceConfig::default_cargo());
- assert!(matches!(sysroot.workspace(), SysrootWorkspace::Workspace(_)));
+ let loaded_sysroot = sysroot.load_workspace(&RustSourceWorkspaceConfig::default_cargo());
+ if let Some(loaded_sysroot) = loaded_sysroot {
+ sysroot.set_workspace(loaded_sysroot);
+ }
+ assert!(matches!(sysroot.workspace(), RustLibSrcWorkspace::Workspace(_)));
let project_workspace = ProjectWorkspace {
kind: ProjectWorkspaceKind::Cargo {
cargo: cargo_workspace,
diff --git a/crates/project-model/src/workspace.rs b/crates/project-model/src/workspace.rs
index dcd62753cb..4f8449cb68 100644
--- a/crates/project-model/src/workspace.rs
+++ b/crates/project-model/src/workspace.rs
@@ -2,7 +2,7 @@
//! metadata` or `rust-project.json`) into representation stored in the salsa
//! database -- `CrateGraph`.
-use std::{collections::VecDeque, fmt, fs, iter, ops::Deref, sync};
+use std::{collections::VecDeque, fmt, fs, iter, ops::Deref, sync, thread};
use anyhow::Context;
use base_db::{
@@ -23,10 +23,10 @@ use crate::{
cargo_workspace::{CargoMetadataConfig, DepKind, PackageData, RustLibSource},
env::{cargo_config_env, inject_cargo_env, inject_cargo_package_env, inject_rustc_tool_env},
project_json::{Crate, CrateArrayIdx},
- sysroot::{SysrootCrate, SysrootWorkspace},
+ sysroot::{RustLibSrcCrate, RustLibSrcWorkspace},
toolchain_info::{rustc_cfg, target_data_layout, target_tuple, version, QueryConfig},
CargoConfig, CargoWorkspace, CfgOverrides, InvocationStrategy, ManifestPath, Package,
- ProjectJson, ProjectManifest, Sysroot, SysrootSourceWorkspaceConfig, TargetData, TargetKind,
+ ProjectJson, ProjectManifest, RustSourceWorkspaceConfig, Sysroot, TargetData, TargetKind,
WorkspaceBuildScripts,
};
use tracing::{debug, error, info};
@@ -186,7 +186,7 @@ impl ProjectWorkspace {
let project_location = project_json.parent().to_path_buf();
let project_json: ProjectJson =
ProjectJson::new(Some(project_json.clone()), &project_location, data);
- ProjectWorkspace::load_inline(project_json, config)
+ ProjectWorkspace::load_inline(project_json, config, progress)
}
ProjectManifest::CargoScript(rust_file) => {
ProjectWorkspace::load_detached_file(rust_file, config)?
@@ -204,19 +204,33 @@ impl ProjectWorkspace {
config: &CargoConfig,
progress: &dyn Fn(String),
) -> Result<ProjectWorkspace, anyhow::Error> {
- let mut sysroot = match (&config.sysroot, &config.sysroot_src) {
+ progress("Discovering sysroot".to_owned());
+ let CargoConfig {
+ features,
+ rustc_source,
+ extra_args,
+ extra_env,
+ set_test,
+ cfg_overrides,
+ extra_includes,
+ sysroot,
+ sysroot_src,
+ target,
+ ..
+ } = config;
+ let mut sysroot = match (sysroot, sysroot_src) {
(Some(RustLibSource::Discover), None) => {
- Sysroot::discover(cargo_toml.parent(), &config.extra_env)
+ Sysroot::discover(cargo_toml.parent(), extra_env)
}
(Some(RustLibSource::Discover), Some(sysroot_src)) => {
Sysroot::discover_with_src_override(
cargo_toml.parent(),
- &config.extra_env,
+ extra_env,
sysroot_src.clone(),
)
}
(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)) => {
Sysroot::new(Some(sysroot.clone()), Some(sysroot_src.clone()))
@@ -224,100 +238,147 @@ impl ProjectWorkspace {
(None, _) => Sysroot::empty(),
};
- let rustc_dir = match &config.rustc_source {
- Some(RustLibSource::Path(path)) => ManifestPath::try_from(path.clone())
- .map_err(|p| Some(format!("rustc source path is not absolute: {p}"))),
- Some(RustLibSource::Discover) => sysroot
- .discover_rustc_src()
- .ok_or_else(|| Some("Failed to discover rustc source for sysroot.".to_owned())),
- None => Err(None),
- };
-
- 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());
let toolchain_config = QueryConfig::Cargo(&sysroot, cargo_toml);
let targets =
- target_tuple::get(toolchain_config, config.target.as_deref(), &config.extra_env)
- .unwrap_or_default();
- let toolchain = version::get(toolchain_config, &config.extra_env)
- .inspect_err(|e| {
- tracing::error!(%e,
- "failed fetching toolchain version for {cargo_toml:?} workspace"
- )
- })
- .ok()
- .flatten();
- let rustc_cfg =
- rustc_cfg::get(toolchain_config, targets.first().map(Deref::deref), &config.extra_env);
- let cfg_overrides = config.cfg_overrides.clone();
- let data_layout = target_data_layout::get(
- toolchain_config,
- targets.first().map(Deref::deref),
- &config.extra_env,
- );
- if let Err(e) = &data_layout {
- tracing::error!(%e, "failed fetching data layout for {cargo_toml:?} workspace");
- }
- sysroot.load_workspace(&SysrootSourceWorkspaceConfig::CargoMetadata(
- sysroot_metadata_config(&config.extra_env, &targets),
- ));
+ target_tuple::get(toolchain_config, target.as_deref(), extra_env).unwrap_or_default();
+
+ // We spawn a bunch of processes to query various information about the workspace's
+ // toolchain and sysroot
+ // We can speed up loading a bit by spawning all of these processes in parallel (especially
+ // on systems were process spawning is delayed)
+ let join = thread::scope(|s| {
+ let workspace_dir = cargo_toml.parent();
+ let toolchain = s.spawn(|| {
+ version::get(toolchain_config, extra_env)
+ .inspect_err(|e| {
+ tracing::error!(%e,
+ "failed fetching toolchain version for {cargo_toml:?} workspace"
+ )
+ })
+ .ok()
+ .flatten()
+ });
- let rustc = rustc_dir.and_then(|rustc_dir| {
- info!(workspace = %cargo_toml, rustc_dir = %rustc_dir, "Using rustc source");
- match CargoWorkspace::fetch_metadata(
- &rustc_dir,
- cargo_toml.parent(),
- &CargoMetadataConfig {
- features: crate::CargoFeatures::default(),
- targets: targets.clone(),
- extra_args: config.extra_args.clone(),
- extra_env: config.extra_env.clone(),
- },
- &sysroot,
- false,
- progress,
- ) {
- Ok((meta, _error)) => {
- let workspace = CargoWorkspace::new(meta, cargo_toml.clone(), Env::default());
- let build_scripts = WorkspaceBuildScripts::rustc_crates(
- &workspace,
- cargo_toml.parent(),
- &config.extra_env,
+ let rustc_cfg = s.spawn(|| {
+ rustc_cfg::get(toolchain_config, targets.first().map(Deref::deref), extra_env)
+ });
+ let data_layout = s.spawn(|| {
+ target_data_layout::get(
+ toolchain_config,
+ targets.first().map(Deref::deref),
+ extra_env,
+ ).inspect_err(|e| {
+ tracing::error!(%e, "failed fetching data layout for {cargo_toml:?} workspace")
+ })
+ });
+
+ let rustc_dir = s.spawn(|| {
+ let rustc_dir = match rustc_source {
+ Some(RustLibSource::Path(path)) => ManifestPath::try_from(path.clone())
+ .map_err(|p| Some(format!("rustc source path is not absolute: {p}"))),
+ Some(RustLibSource::Discover) => {
+ sysroot.discover_rustc_src().ok_or_else(|| {
+ Some("Failed to discover rustc source for sysroot.".to_owned())
+ })
+ }
+ None => Err(None),
+ };
+ rustc_dir.and_then(|rustc_dir| {
+ info!(workspace = %cargo_toml, rustc_dir = %rustc_dir, "Using rustc source");
+ match CargoWorkspace::fetch_metadata(
+ &rustc_dir,
+ workspace_dir,
+ &CargoMetadataConfig {
+ features: crate::CargoFeatures::default(),
+ targets: targets.clone(),
+ extra_args: extra_args.clone(),
+ extra_env: extra_env.clone(),
+ },
&sysroot,
- );
- Ok(Box::new((workspace, build_scripts)))
- }
- Err(e) => {
- tracing::error!(
- %e,
- "Failed to read Cargo metadata from rustc source at {rustc_dir}",
- );
- Err(Some(format!(
- "Failed to read Cargo metadata from rustc source at {rustc_dir}: {e}"
- )))
- }
- }
+ false,
+ &|_| (),
+ ) {
+ Ok((meta, _error)) => {
+ let workspace =
+ CargoWorkspace::new(meta, cargo_toml.clone(), Env::default());
+ let build_scripts = WorkspaceBuildScripts::rustc_crates(
+ &workspace,
+ workspace_dir,
+ extra_env,
+ &sysroot,
+ );
+ Ok(Box::new((workspace, build_scripts)))
+ }
+ Err(e) => {
+ tracing::error!(
+ %e,
+ "Failed to read Cargo metadata from rustc source at {rustc_dir}",
+ );
+ Err(Some(format!(
+ "Failed to read Cargo metadata from rustc source at {rustc_dir}: {e}"
+ )))
+ }
+ }
+ })
+ });
+
+ let cargo_metadata = s.spawn(|| {
+ CargoWorkspace::fetch_metadata(
+ cargo_toml,
+ workspace_dir,
+ &CargoMetadataConfig {
+ features: features.clone(),
+ targets: targets.clone(),
+ extra_args: extra_args.clone(),
+ extra_env: extra_env.clone(),
+ },
+ &sysroot,
+ false,
+ &|_| (),
+ )
+ });
+ let loaded_sysroot = s.spawn(|| {
+ sysroot.load_workspace(&RustSourceWorkspaceConfig::CargoMetadata(
+ sysroot_metadata_config(extra_env, &targets),
+ ))
+ });
+ let cargo_config_extra_env =
+ s.spawn(|| cargo_config_env(cargo_toml, extra_env, &sysroot));
+ thread::Result::Ok((
+ toolchain.join()?,
+ rustc_cfg.join()?,
+ data_layout.join()?,
+ rustc_dir.join()?,
+ loaded_sysroot.join()?,
+ cargo_metadata.join()?,
+ cargo_config_extra_env.join()?,
+ ))
});
- let (meta, error) = CargoWorkspace::fetch_metadata(
- cargo_toml,
- cargo_toml.parent(),
- &CargoMetadataConfig {
- features: config.features.clone(),
- targets,
- extra_args: config.extra_args.clone(),
- extra_env: config.extra_env.clone(),
- },
- &sysroot,
- false,
- progress,
- )
- .with_context(|| {
+ let (
+ toolchain,
+ rustc_cfg,
+ data_layout,
+ rustc,
+ loaded_sysroot,
+ cargo_metadata,
+ cargo_config_extra_env,
+ ) = match join {
+ Ok(it) => it,
+ Err(e) => std::panic::resume_unwind(e),
+ };
+
+ let (meta, error) = cargo_metadata.with_context(|| {
format!(
"Failed to read Cargo metadata from Cargo.toml file {cargo_toml}, {toolchain:?}",
)
})?;
- let cargo_config_extra_env = cargo_config_env(cargo_toml, &config.extra_env, &sysroot);
let cargo = CargoWorkspace::new(meta, cargo_toml.clone(), cargo_config_extra_env);
+ if let Some(loaded_sysroot) = loaded_sysroot {
+ sysroot.set_workspace(loaded_sysroot);
+ }
Ok(ProjectWorkspace {
kind: ProjectWorkspaceKind::Cargo {
@@ -325,33 +386,67 @@ impl ProjectWorkspace {
build_scripts: WorkspaceBuildScripts::default(),
rustc,
error: error.map(Arc::new),
- set_test: config.set_test,
+ set_test: *set_test,
},
sysroot,
rustc_cfg,
- cfg_overrides,
+ cfg_overrides: cfg_overrides.clone(),
toolchain,
target_layout: data_layout.map(Arc::from).map_err(|it| Arc::from(it.to_string())),
- extra_includes: config.extra_includes.clone(),
+ extra_includes: extra_includes.clone(),
})
}
- pub fn load_inline(project_json: ProjectJson, config: &CargoConfig) -> ProjectWorkspace {
+ pub fn load_inline(
+ project_json: ProjectJson,
+ config: &CargoConfig,
+ progress: &dyn Fn(String),
+ ) -> ProjectWorkspace {
+ progress("Discovering sysroot".to_owned());
let mut sysroot =
Sysroot::new(project_json.sysroot.clone(), project_json.sysroot_src.clone());
- sysroot.load_workspace(&SysrootSourceWorkspaceConfig::Stitched);
+ let loaded_sysroot = sysroot.load_workspace(&RustSourceWorkspaceConfig::Stitched);
+ if let Some(loaded_sysroot) = loaded_sysroot {
+ sysroot.set_workspace(loaded_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());
let query_config = QueryConfig::Rustc(&sysroot, project_json.path().as_ref());
- let toolchain = version::get(query_config, &config.extra_env).ok().flatten();
+ let targets = target_tuple::get(query_config, config.target.as_deref(), &config.extra_env)
+ .unwrap_or_default();
+
+ // We spawn a bunch of processes to query various information about the workspace's
+ // toolchain and sysroot
+ // We can speed up loading a bit by spawning all of these processes in parallel (especially
+ // on systems were process spawning is delayed)
+ let join = thread::scope(|s| {
+ let toolchain =
+ s.spawn(|| version::get(query_config, &config.extra_env).ok().flatten());
+ let rustc_cfg = s.spawn(|| {
+ rustc_cfg::get(query_config, targets.first().map(Deref::deref), &config.extra_env)
+ });
+ let data_layout = s.spawn(|| {
+ target_data_layout::get(
+ query_config,
+ targets.first().map(Deref::deref),
+ &config.extra_env,
+ )
+ });
+ thread::Result::Ok((toolchain.join()?, rustc_cfg.join()?, data_layout.join()?))
+ });
+
+ let (toolchain, rustc_cfg, target_layout) = match join {
+ Ok(it) => it,
+ Err(e) => std::panic::resume_unwind(e),
+ };
- let target = config.target.as_deref();
- let rustc_cfg = rustc_cfg::get(query_config, target, &config.extra_env);
- let data_layout = target_data_layout::get(query_config, target, &config.extra_env);
ProjectWorkspace {
kind: ProjectWorkspaceKind::Json(project_json),
sysroot,
rustc_cfg,
toolchain,
- target_layout: data_layout.map(Arc::from).map_err(|it| Arc::from(it.to_string())),
+ target_layout: target_layout.map(Arc::from).map_err(|it| Arc::from(it.to_string())),
cfg_overrides: config.cfg_overrides.clone(),
extra_includes: config.extra_includes.clone(),
}
@@ -363,7 +458,7 @@ impl ProjectWorkspace {
) -> anyhow::Result<ProjectWorkspace> {
let dir = detached_file.parent();
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),
None => Sysroot::empty(),
};
@@ -374,9 +469,12 @@ impl ProjectWorkspace {
.unwrap_or_default();
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);
- sysroot.load_workspace(&SysrootSourceWorkspaceConfig::CargoMetadata(
+ let loaded_sysroot = sysroot.load_workspace(&RustSourceWorkspaceConfig::CargoMetadata(
sysroot_metadata_config(&config.extra_env, &targets),
));
+ if let Some(loaded_sysroot) = loaded_sysroot {
+ sysroot.set_workspace(loaded_sysroot);
+ }
let cargo_script = CargoWorkspace::fetch_metadata(
detached_file,
@@ -545,7 +643,7 @@ impl ProjectWorkspace {
pub fn to_roots(&self) -> Vec<PackageRoot> {
let mk_sysroot = || {
let mut r = match self.sysroot.workspace() {
- SysrootWorkspace::Workspace(ws) => ws
+ RustLibSrcWorkspace::Workspace(ws) => ws
.packages()
.filter_map(|pkg| {
if ws[pkg].is_local {
@@ -566,12 +664,17 @@ impl ProjectWorkspace {
Some(PackageRoot { is_local: false, include, exclude })
})
.collect(),
- SysrootWorkspace::Stitched(_) | SysrootWorkspace::Empty => vec![],
+ RustLibSrcWorkspace::Stitched(_) | RustLibSrcWorkspace::Empty => vec![],
};
r.push(PackageRoot {
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(),
});
r
@@ -1385,7 +1488,7 @@ fn sysroot_to_crate_graph(
) -> (SysrootPublicDeps, Option<CrateId>) {
let _p = tracing::info_span!("sysroot_to_crate_graph").entered();
match sysroot.workspace() {
- SysrootWorkspace::Workspace(cargo) => {
+ RustLibSrcWorkspace::Workspace(cargo) => {
let (mut cg, mut pm) = cargo_to_crate_graph(
load,
None,
@@ -1460,7 +1563,7 @@ fn sysroot_to_crate_graph(
(SysrootPublicDeps { deps: pub_deps }, libproc_macro)
}
- SysrootWorkspace::Stitched(stitched) => {
+ RustLibSrcWorkspace::Stitched(stitched) => {
let cfg_options = Arc::new({
let mut cfg_options = CfgOptions::default();
cfg_options.extend(rustc_cfg);
@@ -1468,7 +1571,7 @@ fn sysroot_to_crate_graph(
cfg_options.insert_atom(sym::miri.clone());
cfg_options
});
- let sysroot_crates: FxHashMap<SysrootCrate, CrateId> = stitched
+ let sysroot_crates: FxHashMap<RustLibSrcCrate, CrateId> = stitched
.crates()
.filter_map(|krate| {
let file_id = load(&stitched[krate].root)?;
@@ -1513,7 +1616,7 @@ fn sysroot_to_crate_graph(
stitched.proc_macro().and_then(|it| sysroot_crates.get(&it).copied());
(public_deps, libproc_macro)
}
- SysrootWorkspace::Empty => (SysrootPublicDeps { deps: vec![] }, None),
+ RustLibSrcWorkspace::Empty => (SysrootPublicDeps { deps: vec![] }, None),
}
}
diff --git a/crates/rust-analyzer/src/cli/rustc_tests.rs b/crates/rust-analyzer/src/cli/rustc_tests.rs
index 199f61e70f..b9b7ad1faf 100644
--- a/crates/rust-analyzer/src/cli/rustc_tests.rs
+++ b/crates/rust-analyzer/src/cli/rustc_tests.rs
@@ -12,8 +12,8 @@ use paths::Utf8PathBuf;
use profile::StopWatch;
use project_model::toolchain_info::{target_data_layout, QueryConfig};
use project_model::{
- CargoConfig, ManifestPath, ProjectWorkspace, ProjectWorkspaceKind, RustLibSource, Sysroot,
- SysrootSourceWorkspaceConfig,
+ CargoConfig, ManifestPath, ProjectWorkspace, ProjectWorkspaceKind, RustLibSource,
+ RustSourceWorkspaceConfig, Sysroot,
};
use load_cargo::{load_workspace, LoadCargoConfig, ProcMacroServerChoice};
@@ -75,7 +75,11 @@ impl Tester {
};
let mut sysroot = Sysroot::discover(tmp_file.parent().unwrap(), &cargo_config.extra_env);
- sysroot.load_workspace(&SysrootSourceWorkspaceConfig::default_cargo());
+ let loaded_sysroot = sysroot.load_workspace(&RustSourceWorkspaceConfig::default_cargo());
+ if let Some(loaded_sysroot) = loaded_sysroot {
+ sysroot.set_workspace(loaded_sysroot);
+ }
+
let data_layout = target_data_layout::get(
QueryConfig::Rustc(&sysroot, tmp_file.parent().unwrap().as_ref()),
None,
diff --git a/crates/rust-analyzer/src/reload.rs b/crates/rust-analyzer/src/reload.rs
index e3c003dbf8..ba72ea35df 100644
--- a/crates/rust-analyzer/src/reload.rs
+++ b/crates/rust-analyzer/src/reload.rs
@@ -316,6 +316,7 @@ impl GlobalState {
let workspace = project_model::ProjectWorkspace::load_inline(
it.clone(),
&cargo_config,
+ &progress,
);
Ok(workspace)
}
diff --git a/crates/rust-analyzer/tests/slow-tests/main.rs b/crates/rust-analyzer/tests/slow-tests/main.rs
index e764bd4770..6f26bdc2cf 100644
--- a/crates/rust-analyzer/tests/slow-tests/main.rs
+++ b/crates/rust-analyzer/tests/slow-tests/main.rs
@@ -1152,7 +1152,11 @@ fn resolve_proc_macro() {
&AbsPathBuf::assert_utf8(std::env::current_dir().unwrap()),
&Default::default(),
);
- sysroot.load_workspace(&project_model::SysrootSourceWorkspaceConfig::default_cargo());
+ let loaded_sysroot =
+ sysroot.load_workspace(&project_model::RustSourceWorkspaceConfig::default_cargo());
+ if let Some(loaded_sysroot) = loaded_sysroot {
+ sysroot.set_workspace(loaded_sysroot);
+ }
let proc_macro_server_path = sysroot.discover_proc_macro_srv().unwrap();