itsscb/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-01 11:31:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #18807 from Veykril/push-vxopsoummyzx

Browse Source 
fix: Populate cargo config env vars for crates
This commit is contained in:
Lukas Wirth 2024-12-31 14:06:36 +00:00 committed by GitHub
commit dcee5fd71f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 77 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
crates/project-model/src/cargo_workspace.rs
View File

@ -4,6 +4,7 @@ use std::ops;
use std::str::from_utf8; use std::str::from_utf8;
use anyhow::Context; use anyhow::Context;
use base_db::Env;
use cargo_metadata::{CargoOpt, MetadataCommand}; use cargo_metadata::{CargoOpt, MetadataCommand};
use la_arena::{Arena, Idx}; use la_arena::{Arena, Idx};
use paths::{AbsPath, AbsPathBuf, Utf8PathBuf}; use paths::{AbsPath, AbsPathBuf, Utf8PathBuf};
@ -34,6 +35,8 @@ pub struct CargoWorkspace {
target_directory: AbsPathBuf, target_directory: AbsPathBuf,
manifest_path: ManifestPath, manifest_path: ManifestPath,
is_virtual_workspace: bool, is_virtual_workspace: bool,
/// Environment variables set in the `.cargo/config` file.
config_env: Env,
} }
impl ops::Index<Package> for CargoWorkspace { impl ops::Index<Package> for CargoWorkspace {
@ -395,6 +398,7 @@ impl CargoWorkspace {
pub fn new( pub fn new(
mut meta: cargo_metadata::Metadata, mut meta: cargo_metadata::Metadata,
ws_manifest_path: ManifestPath, ws_manifest_path: ManifestPath,
cargo_config_env: Env,
) -> CargoWorkspace { ) -> CargoWorkspace {
let mut pkg_by_id = FxHashMap::default(); let mut pkg_by_id = FxHashMap::default();
let mut packages = Arena::default(); let mut packages = Arena::default();
@ -516,6 +520,7 @@ impl CargoWorkspace {
target_directory, target_directory,
manifest_path: ws_manifest_path, manifest_path: ws_manifest_path,
is_virtual_workspace, is_virtual_workspace,
config_env: cargo_config_env,
} }
} }
@ -602,4 +607,8 @@ impl CargoWorkspace {
pub fn is_virtual_workspace(&self) -> bool { pub fn is_virtual_workspace(&self) -> bool {
self.is_virtual_workspace self.is_virtual_workspace
} }
pub fn env(&self) -> &Env {
&self.config_env
}
} }

51
crates/project-model/src/env.rs
View File

@ -1,5 +1,6 @@
//! Cargo-like environment variables injection. //! Cargo-like environment variables injection.
use base_db::Env; use base_db::Env;
use paths::Utf8Path;
use rustc_hash::FxHashMap; use rustc_hash::FxHashMap;
use toolchain::Tool; use toolchain::Tool;
@ -73,7 +74,7 @@ pub(crate) fn cargo_config_env(
manifest: &ManifestPath, manifest: &ManifestPath,
extra_env: &FxHashMap<String, String>, extra_env: &FxHashMap<String, String>,
sysroot: &Sysroot, sysroot: &Sysroot,
) -> FxHashMap<String, String> { ) -> Env {
let mut cargo_config = sysroot.tool(Tool::Cargo, manifest.parent()); let mut cargo_config = sysroot.tool(Tool::Cargo, manifest.parent());
cargo_config.envs(extra_env); cargo_config.envs(extra_env);
cargo_config cargo_config
@ -85,7 +86,7 @@ pub(crate) fn cargo_config_env(
// if successful we receive `env.key.value = "value" per entry // if successful we receive `env.key.value = "value" per entry
tracing::debug!("Discovering cargo config env by {:?}", cargo_config); tracing::debug!("Discovering cargo config env by {:?}", cargo_config);
utf8_stdout(&mut cargo_config) utf8_stdout(&mut cargo_config)
.map(parse_output_cargo_config_env) .map(|stdout| parse_output_cargo_config_env(manifest, stdout))
.inspect(|env| { .inspect(|env| {
tracing::debug!("Discovered cargo config env: {:?}", env); tracing::debug!("Discovered cargo config env: {:?}", env);
}) })
@ -95,18 +96,38 @@ pub(crate) fn cargo_config_env(
.unwrap_or_default() .unwrap_or_default()
} }
fn parse_output_cargo_config_env(stdout: String) -> FxHashMap<String, String> { fn parse_output_cargo_config_env(manifest: &ManifestPath, stdout: String) -> Env {
stdout let mut env = Env::default();
.lines() let mut relatives = vec![];
.filter_map(|l| l.strip_prefix("env.")) for (key, val) in
.filter_map(|l| l.split_once(" = ")) stdout.lines().filter_map(|l| l.strip_prefix("env.")).filter_map(|l| l.split_once(" = "))
.filter_map(|(k, v)| { {
if k.contains('.') { let val = val.trim_matches('"').to_owned();
k.strip_suffix(".value").zip(Some(v)) if let Some((key, modifier)) = key.split_once('.') {
} else { match modifier {
Some((k, v)) "relative" => relatives.push((key, val)),
"value" => _ = env.insert(key, val),
_ => {
tracing::warn!(
"Unknown modifier in cargo config env: {}, expected `relative` or `value`",
modifier
);
continue;
}
} }
}) } else {
.map(|(key, value)| (key.to_owned(), value.trim_matches('"').to_owned())) env.insert(key, val);
.collect() }
}
// FIXME: The base here should be the parent of the `.cargo/config` file, not the manifest.
// But cargo does not provide this information.
let base = <_ as AsRef<Utf8Path>>::as_ref(manifest.parent());
for (key, val) in relatives {
if let Some(val) = env.get(&val) {
env.insert(key, base.join(val).to_string());
} else {
env.insert(key, base.to_string());
}
}
env
} }

2
crates/project-model/src/sysroot.rs
View File

@ -422,7 +422,7 @@ impl Sysroot {
res.packages.remove(idx); res.packages.remove(idx);
}); });
let cargo_workspace = CargoWorkspace::new(res, library_manifest); let cargo_workspace = CargoWorkspace::new(res, library_manifest, Default::default());
Some(Sysroot { Some(Sysroot {
root: sysroot_dir.clone(), root: sysroot_dir.clone(),
src_root: Some(sysroot_src_dir.clone()), src_root: Some(sysroot_src_dir.clone()),

6
crates/project-model/src/tests.rs
View File

@ -28,13 +28,12 @@ fn load_cargo_with_overrides(
let meta: Metadata = get_test_json_file(file); let meta: Metadata = get_test_json_file(file);
let manifest_path = let manifest_path =
ManifestPath::try_from(AbsPathBuf::try_from(meta.workspace_root.clone()).unwrap()).unwrap(); ManifestPath::try_from(AbsPathBuf::try_from(meta.workspace_root.clone()).unwrap()).unwrap();
let cargo_workspace = CargoWorkspace::new(meta, manifest_path); let cargo_workspace = CargoWorkspace::new(meta, manifest_path, Default::default());
let project_workspace = ProjectWorkspace { let project_workspace = ProjectWorkspace {
kind: ProjectWorkspaceKind::Cargo { kind: ProjectWorkspaceKind::Cargo {
cargo: cargo_workspace, cargo: cargo_workspace,
build_scripts: WorkspaceBuildScripts::default(), build_scripts: WorkspaceBuildScripts::default(),
rustc: Err(None), rustc: Err(None),
cargo_config_extra_env: Default::default(),
error: None, error: None,
set_test: true, set_test: true,
}, },
@ -228,7 +227,7 @@ fn smoke_test_real_sysroot_cargo() {
let meta: Metadata = get_test_json_file("hello-world-metadata.json"); let meta: Metadata = get_test_json_file("hello-world-metadata.json");
let manifest_path = let manifest_path =
ManifestPath::try_from(AbsPathBuf::try_from(meta.workspace_root.clone()).unwrap()).unwrap(); ManifestPath::try_from(AbsPathBuf::try_from(meta.workspace_root.clone()).unwrap()).unwrap();
let cargo_workspace = CargoWorkspace::new(meta, manifest_path); let cargo_workspace = CargoWorkspace::new(meta, manifest_path, Default::default());
let sysroot = Sysroot::discover( let sysroot = Sysroot::discover(
AbsPath::assert(Utf8Path::new(env!("CARGO_MANIFEST_DIR"))), AbsPath::assert(Utf8Path::new(env!("CARGO_MANIFEST_DIR"))),
&Default::default(), &Default::default(),
@ -240,7 +239,6 @@ fn smoke_test_real_sysroot_cargo() {
cargo: cargo_workspace, cargo: cargo_workspace,
build_scripts: WorkspaceBuildScripts::default(), build_scripts: WorkspaceBuildScripts::default(),
rustc: Err(None), rustc: Err(None),
cargo_config_extra_env: Default::default(),
error: None, error: None,
set_test: true, set_test: true,
}, },

93
crates/project-model/src/workspace.rs
View File

@ -78,8 +78,6 @@ pub enum ProjectWorkspaceKind {
/// The rustc workspace loaded for this workspace. An `Err(None)` means loading has been /// The rustc workspace loaded for this workspace. An `Err(None)` means loading has been
/// disabled or was otherwise not requested. /// disabled or was otherwise not requested.
rustc: Result<Box<(CargoWorkspace, WorkspaceBuildScripts)>, Option<String>>, rustc: Result<Box<(CargoWorkspace, WorkspaceBuildScripts)>, Option<String>>,
/// Environment variables set in the `.cargo/config` file.
cargo_config_extra_env: FxHashMap<String, String>,
set_test: bool, set_test: bool,
}, },
/// Project workspace was specified using a `rust-project.json` file. /// Project workspace was specified using a `rust-project.json` file.
@ -99,8 +97,6 @@ pub enum ProjectWorkspaceKind {
file: ManifestPath, file: ManifestPath,
/// Is this file a cargo script file? /// Is this file a cargo script file?
cargo: Option<(CargoWorkspace, WorkspaceBuildScripts, Option<Arc<anyhow::Error>>)>, cargo: Option<(CargoWorkspace, WorkspaceBuildScripts, Option<Arc<anyhow::Error>>)>,
/// Environment variables set in the `.cargo/config` file.
cargo_config_extra_env: FxHashMap<String, String>,
set_test: bool, set_test: bool,
}, },
} }
@ -110,14 +106,7 @@ impl fmt::Debug for ProjectWorkspace {
// Make sure this isn't too verbose. // Make sure this isn't too verbose.
let Self { kind, sysroot, rustc_cfg, toolchain, target_layout, cfg_overrides } = self; let Self { kind, sysroot, rustc_cfg, toolchain, target_layout, cfg_overrides } = self;
match kind { match kind {
ProjectWorkspaceKind::Cargo { ProjectWorkspaceKind::Cargo { cargo, error: _, build_scripts, rustc, set_test } => f
cargo,
error: _,
build_scripts,
rustc,
cargo_config_extra_env,
set_test,
} => f
.debug_struct("Cargo") .debug_struct("Cargo")
.field("root", &cargo.workspace_root().file_name()) .field("root", &cargo.workspace_root().file_name())
.field("n_packages", &cargo.packages().len()) .field("n_packages", &cargo.packages().len())
@ -130,7 +119,6 @@ impl fmt::Debug for ProjectWorkspace {
.field("n_cfg_overrides", &cfg_overrides.len()) .field("n_cfg_overrides", &cfg_overrides.len())
.field("toolchain", &toolchain) .field("toolchain", &toolchain)
.field("data_layout", &target_layout) .field("data_layout", &target_layout)
.field("cargo_config_extra_env", &cargo_config_extra_env)
.field("set_test", set_test) .field("set_test", set_test)
.field("build_scripts", &build_scripts.error().unwrap_or("ok")) .field("build_scripts", &build_scripts.error().unwrap_or("ok"))
.finish(), .finish(),
@ -146,12 +134,7 @@ impl fmt::Debug for ProjectWorkspace {
debug_struct.finish() debug_struct.finish()
} }
ProjectWorkspaceKind::DetachedFile { ProjectWorkspaceKind::DetachedFile { file, cargo: cargo_script, set_test } => f
file,
cargo: cargo_script,
cargo_config_extra_env,
set_test,
} => f
.debug_struct("DetachedFiles") .debug_struct("DetachedFiles")
.field("file", &file) .field("file", &file)
.field("cargo_script", &cargo_script.is_some()) .field("cargo_script", &cargo_script.is_some())
@ -161,7 +144,6 @@ impl fmt::Debug for ProjectWorkspace {
.field("toolchain", &toolchain) .field("toolchain", &toolchain)
.field("data_layout", &target_layout) .field("data_layout", &target_layout)
.field("n_cfg_overrides", &cfg_overrides.len()) .field("n_cfg_overrides", &cfg_overrides.len())
.field("cargo_config_extra_env", &cargo_config_extra_env)
.field("set_test", set_test) .field("set_test", set_test)
.finish(), .finish(),
} }
@ -289,14 +271,14 @@ impl ProjectWorkspace {
progress, progress,
) { ) {
Ok((meta, _error)) => { Ok((meta, _error)) => {
let workspace = CargoWorkspace::new(meta, cargo_toml.clone()); let workspace = CargoWorkspace::new(meta, cargo_toml.clone(), Env::default());
let buildscripts = WorkspaceBuildScripts::rustc_crates( let build_scripts = WorkspaceBuildScripts::rustc_crates(
&workspace, &workspace,
cargo_toml.parent(), cargo_toml.parent(),
&config.extra_env, &config.extra_env,
&sysroot, &sysroot,
); );
Ok(Box::new((workspace, buildscripts))) Ok(Box::new((workspace, build_scripts)))
} }
Err(e) => { Err(e) => {
tracing::error!( tracing::error!(
@ -348,14 +330,13 @@ impl ProjectWorkspace {
"Failed to read Cargo metadata from Cargo.toml file {cargo_toml}, {toolchain:?}", "Failed to read Cargo metadata from Cargo.toml file {cargo_toml}, {toolchain:?}",
) )
})?; })?;
let cargo = CargoWorkspace::new(meta, cargo_toml.clone());
let cargo_config_extra_env = cargo_config_env(cargo_toml, &config.extra_env, &sysroot); 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);
Ok(ProjectWorkspace { Ok(ProjectWorkspace {
kind: ProjectWorkspaceKind::Cargo { kind: ProjectWorkspaceKind::Cargo {
cargo, cargo,
build_scripts: WorkspaceBuildScripts::default(), build_scripts: WorkspaceBuildScripts::default(),
rustc, rustc,
cargo_config_extra_env,
error: error.map(Arc::new), error: error.map(Arc::new),
set_test: config.set_test, set_test: config.set_test,
}, },
@ -450,19 +431,19 @@ impl ProjectWorkspace {
) )
.ok() .ok()
.map(|(ws, error)| { .map(|(ws, error)| {
let cargo_config_extra_env =
cargo_config_env(detached_file, &config.extra_env, &sysroot);
( (
CargoWorkspace::new(ws, detached_file.clone()), CargoWorkspace::new(ws, detached_file.clone(), cargo_config_extra_env),
WorkspaceBuildScripts::default(), WorkspaceBuildScripts::default(),
error.map(Arc::new), error.map(Arc::new),
) )
}); });
let cargo_config_extra_env = cargo_config_env(detached_file, &config.extra_env, &sysroot);
Ok(ProjectWorkspace { Ok(ProjectWorkspace {
kind: ProjectWorkspaceKind::DetachedFile { kind: ProjectWorkspaceKind::DetachedFile {
file: detached_file.to_owned(), file: detached_file.to_owned(),
cargo: cargo_script, cargo: cargo_script,
cargo_config_extra_env,
set_test: config.set_test, set_test: config.set_test,
}, },
sysroot, sysroot,
@ -643,14 +624,7 @@ impl ProjectWorkspace {
.chain(mk_sysroot()) .chain(mk_sysroot())
.unique() .unique()
.collect(), .collect(),
ProjectWorkspaceKind::Cargo { ProjectWorkspaceKind::Cargo { cargo, rustc, build_scripts, error: _, set_test: _ } => {
cargo,
rustc,
build_scripts,
cargo_config_extra_env: _,
error: _,
set_test: _,
} => {
cargo cargo
.packages() .packages()
.map(|pkg| { .map(|pkg| {
@ -787,23 +761,18 @@ impl ProjectWorkspace {
extra_env, extra_env,
cfg_overrides, cfg_overrides,
), ),
ProjectWorkspaceKind::Cargo { ProjectWorkspaceKind::Cargo { cargo, rustc, build_scripts, error: _, set_test } => {
cargo, cargo_to_crate_graph(
rustc, load,
build_scripts, rustc.as_ref().map(|a| a.as_ref()).ok(),
cargo_config_extra_env: _, cargo,
error: _, sysroot,
set_test, rustc_cfg.clone(),
} => cargo_to_crate_graph( cfg_overrides,
load, build_scripts,
rustc.as_ref().map(|a| a.as_ref()).ok(), *set_test,
cargo, )
sysroot, }
rustc_cfg.clone(),
cfg_overrides,
build_scripts,
*set_test,
),
ProjectWorkspaceKind::DetachedFile { file, cargo: cargo_script, set_test, .. } => { ProjectWorkspaceKind::DetachedFile { file, cargo: cargo_script, set_test, .. } => {
if let Some((cargo, build_scripts, _)) = cargo_script { if let Some((cargo, build_scripts, _)) = cargo_script {
cargo_to_crate_graph( cargo_to_crate_graph(
@ -848,7 +817,6 @@ impl ProjectWorkspace {
ProjectWorkspaceKind::Cargo { ProjectWorkspaceKind::Cargo {
cargo, cargo,
rustc, rustc,
cargo_config_extra_env,
build_scripts: _, build_scripts: _,
error: _, error: _,
set_test: _, set_test: _,
@ -856,16 +824,11 @@ impl ProjectWorkspace {
ProjectWorkspaceKind::Cargo { ProjectWorkspaceKind::Cargo {
cargo: o_cargo, cargo: o_cargo,
rustc: o_rustc, rustc: o_rustc,
cargo_config_extra_env: o_cargo_config_extra_env,
build_scripts: _, build_scripts: _,
error: _, error: _,
set_test: _, set_test: _,
}, },
) => { ) => cargo == o_cargo && rustc == o_rustc,
cargo == o_cargo
&& rustc == o_rustc
&& cargo_config_extra_env == o_cargo_config_extra_env
}
(ProjectWorkspaceKind::Json(project), ProjectWorkspaceKind::Json(o_project)) => { (ProjectWorkspaceKind::Json(project), ProjectWorkspaceKind::Json(o_project)) => {
project == o_project project == o_project
} }
@ -873,20 +836,14 @@ impl ProjectWorkspace {
ProjectWorkspaceKind::DetachedFile { ProjectWorkspaceKind::DetachedFile {
file, file,
cargo: Some((cargo_script, _, _)), cargo: Some((cargo_script, _, _)),
cargo_config_extra_env,
set_test: _, set_test: _,
}, },
ProjectWorkspaceKind::DetachedFile { ProjectWorkspaceKind::DetachedFile {
file: o_file, file: o_file,
cargo: Some((o_cargo_script, _, _)), cargo: Some((o_cargo_script, _, _)),
cargo_config_extra_env: o_cargo_config_extra_env,
set_test: _, set_test: _,
}, },
) => { ) => file == o_file && cargo_script == o_cargo_script,
file == o_file
&& cargo_script == o_cargo_script
&& cargo_config_extra_env == o_cargo_config_extra_env
}
_ => return false, _ => return false,
}) && sysroot == o_sysroot }) && sysroot == o_sysroot
&& rustc_cfg == o_rustc_cfg && rustc_cfg == o_rustc_cfg
@ -1402,7 +1359,7 @@ fn add_target_crate_root(
opts opts
}; };
let mut env = Env::default(); let mut env = cargo.env().clone();
inject_cargo_package_env(&mut env, pkg); inject_cargo_package_env(&mut env, pkg);
inject_cargo_env(&mut env); inject_cargo_env(&mut env);
inject_rustc_tool_env(&mut env, cargo, cargo_name, kind); inject_rustc_tool_env(&mut env, cargo, cargo_name, kind);

1
crates/rust-analyzer/src/cli/rustc_tests.rs
View File

@ -89,7 +89,6 @@ impl Tester {
kind: ProjectWorkspaceKind::DetachedFile { kind: ProjectWorkspaceKind::DetachedFile {
file: ManifestPath::try_from(tmp_file).unwrap(), file: ManifestPath::try_from(tmp_file).unwrap(),
cargo: None, cargo: None,
cargo_config_extra_env: Default::default(),
set_test: true, set_test: true,
}, },
sysroot, sysroot,

11
crates/rust-analyzer/src/reload.rs
View File

@ -630,13 +630,10 @@ impl GlobalState {
}; };
let env: FxHashMap<_, _> = match &ws.kind { let env: FxHashMap<_, _> = match &ws.kind {
ProjectWorkspaceKind::Cargo { cargo_config_extra_env, .. } ProjectWorkspaceKind::Cargo { cargo, .. }
| ProjectWorkspaceKind::DetachedFile { | ProjectWorkspaceKind::DetachedFile { cargo: Some((cargo, ..)), .. } => cargo
cargo: Some(_), .env()
cargo_config_extra_env, .into_iter()
..
} => cargo_config_extra_env
.iter()
.chain(self.config.extra_env(None)) .chain(self.config.extra_env(None))
.map(|(a, b)| (a.clone(), b.clone())) .map(|(a, b)| (a.clone(), b.clone()))
.chain( .chain(