mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #17108 - Veykril:rustc-ws-hacks, r=Veykril

Browse Source 
internal: Cleanup cfg and env handling in project-model

Fixes https://github.com/rust-lang/rust-analyzer/issues/16122#issuecomment-2065794340

`miri` and `debug_assertions` are now enabled via the `cargo.cfgs` config by default, allowing them to be disabled by overwriting the config.
This commit is contained in:
bors 2024-04-19 16:00:54 +00:00
commit 50bdeaad07
23 changed files with 516 additions and 323 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
crates/base-db/src/input.rs
View File

@ -295,11 +295,30 @@ pub struct CrateData {
pub is_proc_macro: bool,
}
#[derive(Default, Debug, Clone, PartialEq, Eq)]
#[derive(Default, Clone, PartialEq, Eq)]
pub struct Env {
entries: FxHashMap<String, String>,
}
impl fmt::Debug for Env {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
struct EnvDebug<'s>(Vec<(&'s String, &'s String)>);
impl fmt::Debug for EnvDebug<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_map().entries(self.0.iter().copied()).finish()
}
}
f.debug_struct("Env")
.field("entries", &{
let mut entries: Vec<_> = self.entries.iter().collect();
entries.sort();
EnvDebug(entries)
})
.finish()
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Dependency {
pub crate_id: CrateId,
@ -331,10 +350,11 @@ pub fn add_crate_root(
version: Option<String>,
cfg_options: Arc<CfgOptions>,
potential_cfg_options: Option<Arc<CfgOptions>>,
env: Env,
mut env: Env,
is_proc_macro: bool,
origin: CrateOrigin,
) -> CrateId {
env.entries.shrink_to_fit();
let data = CrateData {
root_file_id,
edition,
@ -651,16 +671,24 @@ fn from_iter<T: IntoIterator<Item = (String, String)>>(iter: T) -> Self {
}
impl Env {
pub fn set(&mut self, env: &str, value: String) {
self.entries.insert(env.to_owned(), value);
pub fn set(&mut self, env: &str, value: impl Into<String>) {
self.entries.insert(env.to_owned(), value.into());
}
pub fn get(&self, env: &str) -> Option<String> {
self.entries.get(env).cloned()
}
pub fn iter(&self) -> impl Iterator<Item = (&str, &str)> {
self.entries.iter().map(|(k, v)| (k.as_str(), v.as_str()))
pub fn extend_from_other(&mut self, other: &Env) {
self.entries.extend(other.entries.iter().map(|(x, y)| (x.to_owned(), y.to_owned())));
}
}
impl From<Env> for Vec<(String, String)> {
fn from(env: Env) -> Vec<(String, String)> {
let mut entries: Vec<_> = env.entries.into_iter().collect();
entries.sort();
entries
}
}

7
crates/cfg/src/lib.rs
View File

@ -58,13 +58,6 @@ pub fn insert_key_value(&mut self, key: SmolStr, value: SmolStr) {
self.enabled.insert(CfgAtom::KeyValue { key, value });
}
pub fn difference<'a>(
&'a self,
other: &'a CfgOptions,
) -> impl Iterator<Item = &'a CfgAtom> + 'a {
self.enabled.difference(&other.enabled)
}
pub fn apply_diff(&mut self, diff: CfgDiff) {
for atom in diff.enable {
self.enabled.insert(atom);

3
crates/load-cargo/src/lib.rs
View File

@ -407,8 +407,7 @@ fn expand(
call_site: Span,
mixed_site: Span,
) -> Result<tt::Subtree<Span>, ProcMacroExpansionError> {
let env = env.iter().map(|(k, v)| (k.to_owned(), v.to_owned())).collect();
match self.0.expand(subtree, attrs, env, def_site, call_site, mixed_site) {
match self.0.expand(subtree, attrs, env.clone(), def_site, call_site, mixed_site) {
Ok(Ok(subtree)) => Ok(subtree),
Ok(Err(err)) => Err(ProcMacroExpansionError::Panic(err.0)),
Err(err) => Err(ProcMacroExpansionError::System(err.to_string())),

10
crates/proc-macro-api/src/lib.rs
View File

@ -11,6 +11,7 @@
mod process;
mod version;
use base_db::Env;
use indexmap::IndexSet;
use paths::AbsPathBuf;
use rustc_hash::FxHashMap;
@ -152,16 +153,13 @@ pub fn expand(
&self,
subtree: &tt::Subtree<Span>,
attr: Option<&tt::Subtree<Span>>,
env: Vec<(String, String)>,
env: Env,
def_site: Span,
call_site: Span,
mixed_site: Span,
) -> Result<Result<tt::Subtree<Span>, PanicMessage>, ServerError> {
let version = self.process.lock().unwrap_or_else(|e| e.into_inner()).version();
let current_dir = env
.iter()
.find(|(name, _)| name == "CARGO_MANIFEST_DIR")
.map(|(_, value)| value.clone());
let current_dir = env.get("CARGO_MANIFEST_DIR");
let mut span_data_table = IndexSet::default();
let def_site = span_data_table.insert_full(def_site).0;
@ -172,7 +170,7 @@ pub fn expand(
macro_name: self.name.to_string(),
attributes: attr.map(|subtree| FlatTree::new(subtree, version, &mut span_data_table)),
lib: self.dylib_path.to_path_buf().into(),
env,
env: env.into(),
current_dir,
has_global_spans: ExpnGlobals {
serialize: version >= HAS_GLOBAL_SPANS,

4
crates/project-model/src/build_scripts.rs
View File

@ -23,16 +23,18 @@
use toolchain::Tool;
use crate::{
cfg_flag::CfgFlag, utf8_stdout, CargoConfig, CargoFeatures, CargoWorkspace, InvocationLocation,
cfg::CfgFlag, utf8_stdout, CargoConfig, CargoFeatures, CargoWorkspace, InvocationLocation,
InvocationStrategy, Package, Sysroot, TargetKind,
};
/// Output of the build script and proc-macro building steps for a workspace.
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct WorkspaceBuildScripts {
outputs: ArenaMap<Package, BuildScriptOutput>,
error: Option<String>,
}
/// Output of the build script and proc-macro building step for a concrete package.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub(crate) struct BuildScriptOutput {
/// List of config flags defined by this package's build script.

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

@ -135,6 +135,20 @@ pub struct PackageData {
pub active_features: Vec<String>,
/// String representation of package id
pub id: String,
/// Authors as given in the `Cargo.toml`
pub authors: Vec<String>,
/// Description as given in the `Cargo.toml`
pub description: Option<String>,
/// Homepage as given in the `Cargo.toml`
pub homepage: Option<String>,
/// License as given in the `Cargo.toml`
pub license: Option<String>,
/// License file as given in the `Cargo.toml`
pub license_file: Option<Utf8PathBuf>,
/// Readme file as given in the `Cargo.toml`
pub readme: Option<Utf8PathBuf>,
/// Rust version as given in the `Cargo.toml`
pub rust_version: Option<semver::Version>,
/// The contents of [package.metadata.rust-analyzer]
pub metadata: RustAnalyzerPackageMetaData,
}
@ -225,6 +239,10 @@ fn new(kinds: &[String]) -> TargetKind {
}
TargetKind::Other
}
pub fn is_executable(self) -> bool {
matches!(self, TargetKind::Bin | TargetKind::Example)
}
}
// Deserialize helper for the cargo metadata
@ -330,6 +348,13 @@ pub fn new(mut meta: cargo_metadata::Metadata) -> CargoWorkspace {
repository,
edition,
metadata,
authors,
description,
homepage,
license,
license_file,
readme,
rust_version,
..
} = meta_pkg;
let meta = from_value::<PackageMetadata>(metadata).unwrap_or_default();
@ -358,6 +383,13 @@ pub fn new(mut meta: cargo_metadata::Metadata) -> CargoWorkspace {
is_member,
edition,
repository,
authors,
description,
homepage,
license,
license_file,
readme,
rust_version,
dependencies: Vec::new(),
features: features.into_iter().collect(),
active_features: Vec::new(),

27
crates/project-model/src/cfg_flag.rs → crates/project-model/src/cfg.rs
View File

@ -3,7 +3,8 @@
//! rustc main.rs --cfg foo --cfg 'feature="bar"'
use std::{fmt, str::FromStr};
use cfg::CfgOptions;
use cfg::{CfgDiff, CfgOptions};
use rustc_hash::FxHashMap;
use serde::Serialize;
#[derive(Clone, Eq, PartialEq, Debug, Serialize)]
@ -70,3 +71,27 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
}
}
}
/// A set of cfg-overrides per crate.
#[derive(Default, Debug, Clone, Eq, PartialEq)]
pub struct CfgOverrides {
/// A global set of overrides matching all crates.
pub global: CfgDiff,
/// A set of overrides matching specific crates.
pub selective: FxHashMap<String, CfgDiff>,
}
impl CfgOverrides {
pub fn len(&self) -> usize {
self.global.len() + self.selective.values().map(|it| it.len()).sum::<usize>()
}
pub fn apply(&self, cfg_options: &mut CfgOptions, name: &str) {
if !self.global.is_empty() {
cfg_options.apply_diff(self.global.clone());
};
if let Some(diff) = self.selective.get(name) {
cfg_options.apply_diff(diff.clone());
};
}
}

85
crates/project-model/src/env.rs Normal file
View File

@ -0,0 +1,85 @@
//! Cargo-like environment variables injection.
use base_db::Env;
use rustc_hash::FxHashMap;
use toolchain::Tool;
use crate::{utf8_stdout, ManifestPath, PackageData, Sysroot, TargetKind};
/// Recreates the compile-time environment variables that Cargo sets.
///
/// Should be synced with
/// <https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-crates>
///
/// FIXME: ask Cargo to provide this data instead of re-deriving.
pub(crate) fn inject_cargo_package_env(env: &mut Env, package: &PackageData) {
// FIXME: Missing variables:
// CARGO_BIN_NAME, CARGO_BIN_EXE_<name>
let manifest_dir = package.manifest.parent();
env.set("CARGO_MANIFEST_DIR", manifest_dir.as_str());
env.set("CARGO_PKG_VERSION", package.version.to_string());
env.set("CARGO_PKG_VERSION_MAJOR", package.version.major.to_string());
env.set("CARGO_PKG_VERSION_MINOR", package.version.minor.to_string());
env.set("CARGO_PKG_VERSION_PATCH", package.version.patch.to_string());
env.set("CARGO_PKG_VERSION_PRE", package.version.pre.to_string());
env.set("CARGO_PKG_AUTHORS", package.authors.join(":").clone());
env.set("CARGO_PKG_NAME", package.name.clone());
env.set("CARGO_PKG_DESCRIPTION", package.description.as_deref().unwrap_or_default());
env.set("CARGO_PKG_HOMEPAGE", package.homepage.as_deref().unwrap_or_default());
env.set("CARGO_PKG_REPOSITORY", package.repository.as_deref().unwrap_or_default());
env.set("CARGO_PKG_LICENSE", package.license.as_deref().unwrap_or_default());
env.set(
"CARGO_PKG_LICENSE_FILE",
package.license_file.as_ref().map(ToString::to_string).unwrap_or_default(),
);
env.set(
"CARGO_PKG_README",
package.readme.as_ref().map(ToString::to_string).unwrap_or_default(),
);
env.set(
"CARGO_PKG_RUST_VERSION",
package.rust_version.as_ref().map(ToString::to_string).unwrap_or_default(),
);
}
pub(crate) fn inject_cargo_env(env: &mut Env) {
env.set("CARGO", Tool::Cargo.path().to_string());
}
pub(crate) fn inject_rustc_tool_env(env: &mut Env, cargo_name: &str, kind: TargetKind) {
_ = kind;
// FIXME
// if kind.is_executable() {
// env.set("CARGO_BIN_NAME", cargo_name);
// }
env.set("CARGO_CRATE_NAME", cargo_name.replace('-', "_"));
}
pub(crate) fn cargo_config_env(
cargo_toml: &ManifestPath,
extra_env: &FxHashMap<String, String>,
sysroot: Option<&Sysroot>,
) -> FxHashMap<String, String> {
let mut cargo_config = Sysroot::tool(sysroot, Tool::Cargo);
cargo_config.envs(extra_env);
cargo_config
.current_dir(cargo_toml.parent())
.args(["-Z", "unstable-options", "config", "get", "env"])
.env("RUSTC_BOOTSTRAP", "1");
// if successful we receive `env.key.value = "value" per entry
tracing::debug!("Discovering cargo config env by {:?}", cargo_config);
utf8_stdout(cargo_config).map(parse_output_cargo_config_env).unwrap_or_default()
}
fn parse_output_cargo_config_env(stdout: String) -> FxHashMap<String, String> {
stdout
.lines()
.filter_map(|l| l.strip_prefix("env."))
.filter_map(|l| l.split_once(".value = "))
.map(|(key, value)| (key.to_owned(), value.trim_matches('"').to_owned()))
.collect()
}

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

@ -19,7 +19,8 @@
mod build_scripts;
mod cargo_workspace;
mod cfg_flag;
mod cfg;
mod env;
mod manifest_path;
mod project_json;
mod rustc_cfg;
@ -47,10 +48,11 @@
CargoConfig, CargoFeatures, CargoWorkspace, Package, PackageData, PackageDependency,
RustLibSource, Target, TargetData, TargetKind,
},
cfg::CfgOverrides,
manifest_path::ManifestPath,
project_json::{ProjectJson, ProjectJsonData},
sysroot::Sysroot,
workspace::{CfgOverrides, PackageRoot, ProjectWorkspace},
workspace::{FileLoader, PackageRoot, ProjectWorkspace},
};
#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]

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

@ -55,7 +55,7 @@
use serde::{de, Deserialize, Serialize};
use span::Edition;
use crate::cfg_flag::CfgFlag;
use crate::cfg::CfgFlag;
/// Roots and crates that compose this Rust project.
#[derive(Clone, Debug, Eq, PartialEq)]

5
crates/project-model/src/rustc_cfg.rs
View File

@ -4,7 +4,7 @@
use rustc_hash::FxHashMap;
use toolchain::Tool;
use crate::{cfg_flag::CfgFlag, utf8_stdout, ManifestPath, Sysroot};
use crate::{cfg::CfgFlag, utf8_stdout, ManifestPath, Sysroot};
/// Determines how `rustc --print cfg` is discovered and invoked.
pub(crate) enum RustcCfgConfig<'a> {
@ -32,9 +32,6 @@ pub(crate) fn get(
}
}
// Add miri cfg, which is useful for mir eval in stdlib
res.push(CfgFlag::Atom("miri".into()));
let rustc_cfgs = get_rust_cfgs(target, extra_env, config);
let rustc_cfgs = match rustc_cfgs {

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

@ -75,6 +75,7 @@ fn load_rust_project(file: &str) -> (CrateGraph, ProcMacroPaths) {
rustc_cfg: Vec::new(),
toolchain: None,
target_layout: Err(Arc::from("test has no data layout")),
cfg_overrides: Default::default(),
};
to_crate_graph(project_workspace)
}
@ -97,6 +98,11 @@ fn fixup_paths(val: &mut serde_json::Value) {
}
}
fn replace_cargo(s: &mut String) {
let path = toolchain::Tool::Cargo.path().to_string().escape_debug().collect::<String>();
*s = s.replace(&path, "$CARGO$");
}
fn replace_root(s: &mut String, direction: bool) {
if direction {
let root = if cfg!(windows) { r#"C:\\ROOT\"# } else { "/ROOT/" };
@ -155,7 +161,9 @@ fn to_crate_graph(project_workspace: ProjectWorkspace) -> (CrateGraph, ProcMacro
fn check_crate_graph(crate_graph: CrateGraph, expect: ExpectFile) {
let mut crate_graph = format!("{crate_graph:#?}");
replace_root(&mut crate_graph, false);
replace_cargo(&mut crate_graph);
replace_fake_sys_root(&mut crate_graph);
expect.assert_eq(&crate_graph);
}

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

@ -2,7 +2,7 @@
//! metadata` or `rust-project.json`) into representation stored in the salsa
//! database -- `CrateGraph`.
use std::{collections::VecDeque, fmt, fs, iter, str::FromStr, sync};
use std::{collections::VecDeque, fmt, fs, iter, sync};
use anyhow::{format_err, Context};
use base_db::{
@ -21,7 +21,8 @@
use crate::{
build_scripts::BuildScriptOutput,
cargo_workspace::{DepKind, PackageData, RustLibSource},
cfg_flag::CfgFlag,
cfg::{CfgFlag, CfgOverrides},
env::{cargo_config_env, inject_cargo_env, inject_cargo_package_env, inject_rustc_tool_env},
project_json::{Crate, CrateArrayIdx},
rustc_cfg::{self, RustcCfgConfig},
sysroot::{SysrootCrate, SysrootMode},
@ -30,29 +31,7 @@
ProjectJson, ProjectManifest, Sysroot, TargetData, TargetKind, WorkspaceBuildScripts,
};
/// A set of cfg-overrides per crate.
#[derive(Default, Debug, Clone, Eq, PartialEq)]
pub struct CfgOverrides {
/// A global set of overrides matching all crates.
pub global: CfgDiff,
/// A set of overrides matching specific crates.
pub selective: FxHashMap<String, CfgDiff>,
}
impl CfgOverrides {
pub fn len(&self) -> usize {
self.global.len() + self.selective.values().map(|it| it.len()).sum::<usize>()
}
fn apply(&self, cfg_options: &mut CfgOptions, name: &str) {
if !self.global.is_empty() {
cfg_options.apply_diff(self.global.clone());
};
if let Some(diff) = self.selective.get(name) {
cfg_options.apply_diff(diff.clone());
};
}
}
pub type FileLoader<'a> = &'a mut dyn for<'b> FnMut(&'b AbsPath) -> Option<FileId>;
/// `PackageRoot` describes a package root folder.
/// Which may be an external dependency, or a member of
@ -69,30 +48,46 @@ pub struct PackageRoot {
pub enum ProjectWorkspace {
/// Project workspace was discovered by running `cargo metadata` and `rustc --print sysroot`.
Cargo {
/// The workspace as returned by `cargo metadata`.
cargo: CargoWorkspace,
/// The build script results for the workspace.
build_scripts: WorkspaceBuildScripts,
/// The sysroot loaded for this workspace.
sysroot: Result<Sysroot, Option<String>>,
/// The rustc workspace loaded for this workspace. An `Err(None)` means loading has been
/// disabled or was otherwise not requested.
rustc: Result<Box<(CargoWorkspace, WorkspaceBuildScripts)>, Option<String>>,
/// Holds cfg flags for the current target. We get those by running
/// `rustc --print cfg`.
///
/// FIXME: make this a per-crate map, as, eg, build.rs might have a
/// different target.
// FIXME: make this a per-crate map, as, eg, build.rs might have a
// different target.
rustc_cfg: Vec<CfgFlag>,
/// A set of cfg overrides for this workspace.
cfg_overrides: CfgOverrides,
/// The toolchain version used by this workspace.
toolchain: Option<Version>,
/// The target data layout queried for workspace.
target_layout: TargetLayoutLoadResult,
/// Environment variables set in the `.cargo/config` file.
cargo_config_extra_env: FxHashMap<String, String>,
},
/// Project workspace was manually specified using a `rust-project.json` file.
Json {
/// The loaded project json file.
project: ProjectJson,
/// The sysroot loaded for this workspace.
sysroot: Result<Sysroot, Option<String>>,
/// Holds cfg flags for the current target. We get those by running
/// `rustc --print cfg`.
// FIXME: make this a per-crate map, as, eg, build.rs might have a
// different target.
rustc_cfg: Vec<CfgFlag>,
/// The toolchain version used by this workspace.
toolchain: Option<Version>,
/// The target data layout queried for workspace.
target_layout: TargetLayoutLoadResult,
/// A set of cfg overrides for this workspace.
cfg_overrides: CfgOverrides,
},
// FIXME: The primary limitation of this approach is that the set of detached files needs to be fixed at the beginning.
// That's not the end user experience we should strive for.
@ -105,13 +100,21 @@ pub enum ProjectWorkspace {
/// Project with a set of disjoint files, not belonging to any particular workspace.
/// Backed by basic sysroot crates for basic completion and highlighting.
DetachedFiles {
/// The set of detached files.
files: Vec<AbsPathBuf>,
/// The sysroot loaded for this workspace.
sysroot: Result<Sysroot, Option<String>>,
/// Holds cfg flags for the current target. We get those by running
/// `rustc --print cfg`.
// FIXME: make this a per-crate map, as, eg, build.rs might have a
// different target.
rustc_cfg: Vec<CfgFlag>,
/// The toolchain version used by this workspace.
toolchain: Option<Version>,
/// The target data layout queried for workspace.
target_layout: TargetLayoutLoadResult,
/// A set of cfg overrides for the files.
cfg_overrides: CfgOverrides,
},
}
@ -150,6 +153,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
rustc_cfg,
toolchain,
target_layout: data_layout,
cfg_overrides,
} => {
let mut debug_struct = f.debug_struct("Json");
debug_struct.field("n_crates", &project.n_crates());
@ -159,7 +163,8 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
debug_struct
.field("n_rustc_cfg", &rustc_cfg.len())
.field("toolchain", &toolchain)
.field("data_layout", &data_layout);
.field("data_layout", &data_layout)
.field("n_cfg_overrides", &cfg_overrides.len());
debug_struct.finish()
}
ProjectWorkspace::DetachedFiles {
@ -168,6 +173,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
rustc_cfg,
toolchain,
target_layout,
cfg_overrides,
} => f
.debug_struct("DetachedFiles")
.field("n_files", &files.len())
@ -175,6 +181,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
.field("n_rustc_cfg", &rustc_cfg.len())
.field("toolchain", &toolchain)
.field("data_layout", &target_layout)
.field("n_cfg_overrides", &cfg_overrides.len())
.finish(),
}
}
@ -228,6 +235,7 @@ fn load_inner(
project_json,
config.target.as_deref(),
&config.extra_env,
&config.cfg_overrides,
)
}
ProjectManifest::CargoToml(cargo_toml) => {
@ -369,6 +377,7 @@ pub fn load_inline(
project_json: ProjectJson,
target: Option<&str>,
extra_env: &FxHashMap<String, String>,
cfg_overrides: &CfgOverrides,
) -> ProjectWorkspace {
let sysroot = match (project_json.sysroot.clone(), project_json.sysroot_src.clone()) {
(Some(sysroot), Some(sysroot_src)) => {
@ -415,6 +424,7 @@ pub fn load_inline(
rustc_cfg,
toolchain,
target_layout: data_layout.map(Arc::from).map_err(|it| Arc::from(it.to_string())),
cfg_overrides: cfg_overrides.clone(),
}
}
@ -465,6 +475,7 @@ pub fn load_detached_files(
rustc_cfg,
toolchain,
target_layout: data_layout.map(Arc::from).map_err(|it| Arc::from(it.to_string())),
cfg_overrides: config.cfg_overrides.clone(),
})
}
@ -620,6 +631,7 @@ pub fn to_roots(&self) -> Vec<PackageRoot> {
rustc_cfg: _,
toolchain: _,
target_layout: _,
cfg_overrides: _,
} => project
.crates()
.map(|(_, krate)| PackageRoot {
@ -723,7 +735,7 @@ pub fn n_packages(&self) -> usize {
pub fn to_crate_graph(
&self,
load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
load: FileLoader<'_>,
extra_env: &FxHashMap<String, String>,
) -> (CrateGraph, ProcMacroPaths) {
let _p = tracing::span!(tracing::Level::INFO, "ProjectWorkspace::to_crate_graph").entered();
@ -735,6 +747,7 @@ pub fn to_crate_graph(
rustc_cfg,
toolchain: _,
target_layout: _,
cfg_overrides,
} => (
project_json_to_crate_graph(
rustc_cfg.clone(),
@ -742,6 +755,7 @@ pub fn to_crate_graph(
project,
sysroot.as_ref().ok(),
extra_env,
cfg_overrides,
),
sysroot,
),
@ -773,12 +787,14 @@ pub fn to_crate_graph(
rustc_cfg,
toolchain: _,
target_layout: _,
cfg_overrides,
} => (
detached_files_to_crate_graph(
rustc_cfg.clone(),
load,
files,
sysroot.as_ref().ok(),
cfg_overrides,
),
sysroot,
),
@ -829,28 +845,45 @@ pub fn eq_ignore_build_data(&self, other: &Self) -> bool {
&& cargo_config_extra_env == o_cargo_config_extra_env
}
(
Self::Json { project, sysroot, rustc_cfg, toolchain, target_layout: _ },
Self::Json {
project,
sysroot,
rustc_cfg,
toolchain,
target_layout: _,
cfg_overrides,
},
Self::Json {
project: o_project,
sysroot: o_sysroot,
rustc_cfg: o_rustc_cfg,
toolchain: o_toolchain,
target_layout: _,
cfg_overrides: o_cfg_overrides,
},
) => {
project == o_project
&& rustc_cfg == o_rustc_cfg
&& sysroot == o_sysroot
&& toolchain == o_toolchain
&& cfg_overrides == o_cfg_overrides
}
(
Self::DetachedFiles { files, sysroot, rustc_cfg, toolchain, target_layout },
Self::DetachedFiles {
files,
sysroot,
rustc_cfg,
toolchain,
target_layout,
cfg_overrides,
},
Self::DetachedFiles {
files: o_files,
sysroot: o_sysroot,
rustc_cfg: o_rustc_cfg,
toolchain: o_toolchain,
target_layout: o_target_layout,
cfg_overrides: o_cfg_overrides,
},
) => {
files == o_files
@ -858,6 +891,7 @@ pub fn eq_ignore_build_data(&self, other: &Self) -> bool {
&& rustc_cfg == o_rustc_cfg
&& toolchain == o_toolchain
&& target_layout == o_target_layout
&& cfg_overrides == o_cfg_overrides
}
_ => false,
}
@ -874,10 +908,11 @@ pub fn is_json(&self) -> bool {
fn project_json_to_crate_graph(
rustc_cfg: Vec<CfgFlag>,
load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
load: FileLoader<'_>,
project: &ProjectJson,
sysroot: Option<&Sysroot>,
extra_env: &FxHashMap<String, String>,
override_cfg: &CfgOverrides,
) -> (CrateGraph, ProcMacroPaths) {
let mut res = (CrateGraph::default(), ProcMacroPaths::default());
let (crate_graph, proc_macros) = &mut res;
@ -917,19 +952,22 @@ fn project_json_to_crate_graph(
None => &rustc_cfg,
};
let mut cfg_options = target_cfgs
.iter()
.chain(cfg.iter())
.chain(iter::once(&r_a_cfg_flag))
.cloned()
.collect();
override_cfg.apply(
&mut cfg_options,
display_name.as_ref().map(|it| it.canonical_name()).unwrap_or_default(),
);
let crate_graph_crate_id = crate_graph.add_crate_root(
file_id,
*edition,
display_name.clone(),
version.clone(),
Arc::new(
target_cfgs
.iter()
.chain(cfg.iter())
.chain(iter::once(&r_a_cfg_flag))
.cloned()
.collect(),
),
Arc::new(cfg_options),
None,
env,
*is_proc_macro,
@ -976,7 +1014,7 @@ fn project_json_to_crate_graph(
}
fn cargo_to_crate_graph(
load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
load: FileLoader<'_>,
rustc: Option<&(CargoWorkspace, WorkspaceBuildScripts)>,
cargo: &CargoWorkspace,
sysroot: Option<&Sysroot>,
@ -993,7 +1031,7 @@ fn cargo_to_crate_graph(
None => (SysrootPublicDeps::default(), None),
};
let cfg_options = create_cfg_options(rustc_cfg);
let cfg_options = CfgOptions::from_iter(rustc_cfg);
// Mapping of a package to its library target
let mut pkg_to_lib_crate = FxHashMap::default();
@ -1166,9 +1204,10 @@ fn cargo_to_crate_graph(
fn detached_files_to_crate_graph(
rustc_cfg: Vec<CfgFlag>,
load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
load: FileLoader<'_>,
detached_files: &[AbsPathBuf],
sysroot: Option<&Sysroot>,
override_cfg: &CfgOverrides,
) -> (CrateGraph, ProcMacroPaths) {
let _p = tracing::span!(tracing::Level::INFO, "detached_files_to_crate_graph").entered();
let mut crate_graph = CrateGraph::default();
@ -1177,8 +1216,10 @@ fn detached_files_to_crate_graph(
None => (SysrootPublicDeps::default(), None),
};
let mut cfg_options = create_cfg_options(rustc_cfg);
let mut cfg_options = CfgOptions::from_iter(rustc_cfg);
cfg_options.insert_atom("test".into());
cfg_options.insert_atom("rust_analyzer".into());
override_cfg.apply(&mut cfg_options, "");
let cfg_options = Arc::new(cfg_options);
for detached_file in detached_files {
@ -1216,7 +1257,7 @@ fn handle_rustc_crates(
crate_graph: &mut CrateGraph,
proc_macros: &mut ProcMacroPaths,
pkg_to_lib_crate: &mut FxHashMap<Package, CrateId>,
load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
load: FileLoader<'_>,
rustc_workspace: &CargoWorkspace,
cargo: &CargoWorkspace,
public_deps: &SysrootPublicDeps,
@ -1350,23 +1391,19 @@ fn add_target_crate_root(
};
let mut env = Env::default();
inject_cargo_env(pkg, &mut env);
if let Ok(cname) = String::from_str(cargo_name) {
// CARGO_CRATE_NAME is the name of the Cargo target with - converted to _, such as the name of the library, binary, example, integration test, or benchmark.
env.set("CARGO_CRATE_NAME", cname.replace('-', "_"));
}
inject_cargo_package_env(&mut env, pkg);
inject_cargo_env(&mut env);
inject_rustc_tool_env(&mut env, cargo_name, kind);
if let Some(envs) = build_data.map(|it| &it.envs) {
for (k, v) in envs {
env.set(k, v.clone());
}
}
let display_name = CrateDisplayName::from_canonical_name(cargo_name.to_owned());
let crate_id = crate_graph.add_crate_root(
file_id,
edition,
Some(display_name),
Some(CrateDisplayName::from_canonical_name(cargo_name.to_owned())),
Some(pkg.version.to_string()),
Arc::new(cfg_options),
potential_cfg_options.map(Arc::new),
@ -1405,7 +1442,7 @@ fn sysroot_to_crate_graph(
crate_graph: &mut CrateGraph,
sysroot: &Sysroot,
rustc_cfg: Vec<CfgFlag>,
load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
load: FileLoader<'_>,
) -> (SysrootPublicDeps, Option<CrateId>) {
let _p = tracing::span!(tracing::Level::INFO, "sysroot_to_crate_graph").entered();
match sysroot.mode() {
@ -1416,7 +1453,17 @@ fn sysroot_to_crate_graph(
cargo,
None,
rustc_cfg,
&CfgOverrides::default(),
&CfgOverrides {
global: CfgDiff::new(
vec![
CfgAtom::Flag("debug_assertions".into()),
CfgAtom::Flag("miri".into()),
],
vec![],
)
.unwrap(),
..Default::default()
},
&WorkspaceBuildScripts::default(),
);
@ -1474,13 +1521,18 @@ fn sysroot_to_crate_graph(
(SysrootPublicDeps { deps: pub_deps }, libproc_macro)
}
SysrootMode::Stitched(stitched) => {
let cfg_options = Arc::new(create_cfg_options(rustc_cfg));
let cfg_options = Arc::new({
let mut cfg_options = CfgOptions::default();
cfg_options.extend(rustc_cfg);
cfg_options.insert_atom("debug_assertions".into());
cfg_options.insert_atom("miri".into());
cfg_options
});
let sysroot_crates: FxHashMap<SysrootCrate, CrateId> = stitched
.crates()
.filter_map(|krate| {
let file_id = load(&stitched[krate].root)?;
let env = Env::default();
let display_name =
CrateDisplayName::from_canonical_name(stitched[krate].name.clone());
let crate_id = crate_graph.add_crate_root(
@ -1490,7 +1542,7 @@ fn sysroot_to_crate_graph(
None,
cfg_options.clone(),
None,
env,
Env::default(),
false,
CrateOrigin::Lang(LangCrateOrigin::from(&*stitched[krate].name)),
);
@ -1548,71 +1600,3 @@ fn add_dep_inner(graph: &mut CrateGraph, from: CrateId, dep: Dependency) {
tracing::error!("{}", err)
}
}
/// Recreates the compile-time environment variables that Cargo sets.
///
/// Should be synced with
/// <https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-crates>
///
/// FIXME: ask Cargo to provide this data instead of re-deriving.
fn inject_cargo_env(package: &PackageData, env: &mut Env) {
// FIXME: Missing variables:
// CARGO_BIN_NAME, CARGO_BIN_EXE_<name>
let manifest_dir = package.manifest.parent();
env.set("CARGO_MANIFEST_DIR", manifest_dir.as_str().to_owned());
// Not always right, but works for common cases.
env.set("CARGO", "cargo".into());
env.set("CARGO_PKG_VERSION", package.version.to_string());
env.set("CARGO_PKG_VERSION_MAJOR", package.version.major.to_string());
env.set("CARGO_PKG_VERSION_MINOR", package.version.minor.to_string());
env.set("CARGO_PKG_VERSION_PATCH", package.version.patch.to_string());
env.set("CARGO_PKG_VERSION_PRE", package.version.pre.to_string());
env.set("CARGO_PKG_AUTHORS", String::new());
env.set("CARGO_PKG_NAME", package.name.clone());
// FIXME: This isn't really correct (a package can have many crates with different names), but
// it's better than leaving the variable unset.
env.set("CARGO_CRATE_NAME", CrateName::normalize_dashes(&package.name).to_string());
env.set("CARGO_PKG_DESCRIPTION", String::new());
env.set("CARGO_PKG_HOMEPAGE", String::new());
env.set("CARGO_PKG_REPOSITORY", String::new());
env.set("CARGO_PKG_LICENSE", String::new());
env.set("CARGO_PKG_LICENSE_FILE", String::new());
}
fn create_cfg_options(rustc_cfg: Vec<CfgFlag>) -> CfgOptions {
let mut cfg_options = CfgOptions::default();
cfg_options.extend(rustc_cfg);
cfg_options.insert_atom("debug_assertions".into());
cfg_options
}
fn cargo_config_env(
cargo_toml: &ManifestPath,
extra_env: &FxHashMap<String, String>,
sysroot: Option<&Sysroot>,
) -> FxHashMap<String, String> {
let mut cargo_config = Sysroot::tool(sysroot, Tool::Cargo);
cargo_config.envs(extra_env);
cargo_config
.current_dir(cargo_toml.parent())
.args(["-Z", "unstable-options", "config", "get", "env"])
.env("RUSTC_BOOTSTRAP", "1");
// if successful we receive `env.key.value = "value" per entry
tracing::debug!("Discovering cargo config env by {:?}", cargo_config);
utf8_stdout(cargo_config).map(parse_output_cargo_config_env).unwrap_or_default()
}
fn parse_output_cargo_config_env(stdout: String) -> FxHashMap<String, String> {
stdout
.lines()
.filter_map(|l| l.strip_prefix("env."))
.filter_map(|l| l.split_once(".value = "))
.map(|(key, value)| (key.to_owned(), value.trim_matches('"').to_owned()))
.collect()
}

108
crates/project-model/test_data/output/cargo_hello_world_project_model.txt
View File

@ -17,7 +17,6 @@
),
cfg_options: CfgOptions(
[
"debug_assertions",
"rust_analyzer",
"test",
],
@ -25,20 +24,22 @@
potential_cfg_options: None,
env: Env {
entries: {
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO": "$CARGO$",
"CARGO_CRATE_NAME": "hello_world",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO": "cargo",
"CARGO_PKG_README": "",
"CARGO_PKG_REPOSITORY": "",
"CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "",
},
},
@ -77,7 +78,6 @@
),
cfg_options: CfgOptions(
[
"debug_assertions",
"rust_analyzer",
"test",
],
@ -85,20 +85,22 @@
potential_cfg_options: None,
env: Env {
entries: {
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO": "$CARGO$",
"CARGO_CRATE_NAME": "hello_world",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO": "cargo",
"CARGO_PKG_README": "",
"CARGO_PKG_REPOSITORY": "",
"CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "",
},
},
@ -144,7 +146,6 @@
),
cfg_options: CfgOptions(
[
"debug_assertions",
"rust_analyzer",
"test",
],
@ -152,20 +153,22 @@
potential_cfg_options: None,
env: Env {
entries: {
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO": "$CARGO$",
"CARGO_CRATE_NAME": "an_example",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO": "cargo",
"CARGO_PKG_README": "",
"CARGO_PKG_REPOSITORY": "",
"CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "",
},
},
@ -211,7 +214,6 @@
),
cfg_options: CfgOptions(
[
"debug_assertions",
"rust_analyzer",
"test",
],
@ -219,20 +221,22 @@
potential_cfg_options: None,
env: Env {
entries: {
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO": "$CARGO$",
"CARGO_CRATE_NAME": "it",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO": "cargo",
"CARGO_PKG_README": "",
"CARGO_PKG_REPOSITORY": "",
"CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "",
},
},
@ -278,7 +282,6 @@
),
cfg_options: CfgOptions(
[
"debug_assertions",
"feature=default",
"feature=std",
],
@ -286,7 +289,6 @@
potential_cfg_options: Some(
CfgOptions(
[
"debug_assertions",
"feature=align",
"feature=const-extern-fn",
"feature=default",
@ -299,20 +301,22 @@
),
env: Env {
entries: {
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$.cargo/registry/src/github.com-1ecc6299db9ec823/libc-0.2.98",
"CARGO_PKG_VERSION": "0.2.98",
"CARGO_PKG_AUTHORS": "",
"CARGO": "$CARGO$",
"CARGO_CRATE_NAME": "libc",
"CARGO_MANIFEST_DIR": "$ROOT$.cargo/registry/src/github.com-1ecc6299db9ec823/libc-0.2.98",
"CARGO_PKG_AUTHORS": "The Rust Project Developers",
"CARGO_PKG_DESCRIPTION": "Raw FFI bindings to platform libraries like libc.\n",
"CARGO_PKG_HOMEPAGE": "https://github.com/rust-lang/libc",
"CARGO_PKG_LICENSE": "MIT OR Apache-2.0",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_NAME": "libc",
"CARGO_PKG_VERSION_PATCH": "98",
"CARGO": "cargo",
"CARGO_PKG_REPOSITORY": "",
"CARGO_PKG_README": "README.md",
"CARGO_PKG_REPOSITORY": "https://github.com/rust-lang/libc",
"CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.2.98",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "2",
"CARGO_PKG_VERSION_PATCH": "98",
"CARGO_PKG_VERSION_PRE": "",
},
},

108
crates/project-model/test_data/output/cargo_hello_world_project_model_with_selective_overrides.txt
View File

@ -17,7 +17,6 @@
),
cfg_options: CfgOptions(
[
"debug_assertions",
"rust_analyzer",
"test",
],
@ -25,20 +24,22 @@
potential_cfg_options: None,
env: Env {
entries: {
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO": "$CARGO$",
"CARGO_CRATE_NAME": "hello_world",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO": "cargo",
"CARGO_PKG_README": "",
"CARGO_PKG_REPOSITORY": "",
"CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "",
},
},
@ -77,7 +78,6 @@
),
cfg_options: CfgOptions(
[
"debug_assertions",
"rust_analyzer",
"test",
],
@ -85,20 +85,22 @@
potential_cfg_options: None,
env: Env {
entries: {
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO": "$CARGO$",
"CARGO_CRATE_NAME": "hello_world",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO": "cargo",
"CARGO_PKG_README": "",
"CARGO_PKG_REPOSITORY": "",
"CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "",
},
},
@ -144,7 +146,6 @@
),
cfg_options: CfgOptions(
[
"debug_assertions",
"rust_analyzer",
"test",
],
@ -152,20 +153,22 @@
potential_cfg_options: None,
env: Env {
entries: {
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO": "$CARGO$",
"CARGO_CRATE_NAME": "an_example",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO": "cargo",
"CARGO_PKG_README": "",
"CARGO_PKG_REPOSITORY": "",
"CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "",
},
},
@ -211,7 +214,6 @@
),
cfg_options: CfgOptions(
[
"debug_assertions",
"rust_analyzer",
"test",
],
@ -219,20 +221,22 @@
potential_cfg_options: None,
env: Env {
entries: {
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO": "$CARGO$",
"CARGO_CRATE_NAME": "it",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO": "cargo",
"CARGO_PKG_README": "",
"CARGO_PKG_REPOSITORY": "",
"CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "",
},
},
@ -278,7 +282,6 @@
),
cfg_options: CfgOptions(
[
"debug_assertions",
"feature=default",
"feature=std",
],
@ -286,7 +289,6 @@
potential_cfg_options: Some(
CfgOptions(
[
"debug_assertions",
"feature=align",
"feature=const-extern-fn",
"feature=default",
@ -299,20 +301,22 @@
),
env: Env {
entries: {
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$.cargo/registry/src/github.com-1ecc6299db9ec823/libc-0.2.98",
"CARGO_PKG_VERSION": "0.2.98",
"CARGO_PKG_AUTHORS": "",
"CARGO": "$CARGO$",
"CARGO_CRATE_NAME": "libc",
"CARGO_MANIFEST_DIR": "$ROOT$.cargo/registry/src/github.com-1ecc6299db9ec823/libc-0.2.98",
"CARGO_PKG_AUTHORS": "The Rust Project Developers",
"CARGO_PKG_DESCRIPTION": "Raw FFI bindings to platform libraries like libc.\n",
"CARGO_PKG_HOMEPAGE": "https://github.com/rust-lang/libc",
"CARGO_PKG_LICENSE": "MIT OR Apache-2.0",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_NAME": "libc",
"CARGO_PKG_VERSION_PATCH": "98",
"CARGO": "cargo",
"CARGO_PKG_REPOSITORY": "",
"CARGO_PKG_README": "README.md",
"CARGO_PKG_REPOSITORY": "https://github.com/rust-lang/libc",
"CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.2.98",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "2",
"CARGO_PKG_VERSION_PATCH": "98",
"CARGO_PKG_VERSION_PRE": "",
},
},

108
crates/project-model/test_data/output/cargo_hello_world_project_model_with_wildcard_overrides.txt
View File

@ -17,27 +17,28 @@
),
cfg_options: CfgOptions(
[
"debug_assertions",
"rust_analyzer",
],
),
potential_cfg_options: None,
env: Env {
entries: {
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO": "$CARGO$",
"CARGO_CRATE_NAME": "hello_world",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO": "cargo",
"CARGO_PKG_README": "",
"CARGO_PKG_REPOSITORY": "",
"CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "",
},
},
@ -76,27 +77,28 @@
),
cfg_options: CfgOptions(
[
"debug_assertions",
"rust_analyzer",
],
),
potential_cfg_options: None,
env: Env {
entries: {
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO": "$CARGO$",
"CARGO_CRATE_NAME": "hello_world",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO": "cargo",
"CARGO_PKG_README": "",
"CARGO_PKG_REPOSITORY": "",
"CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "",
},
},
@ -142,27 +144,28 @@
),
cfg_options: CfgOptions(
[
"debug_assertions",
"rust_analyzer",
],
),
potential_cfg_options: None,
env: Env {
entries: {
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO": "$CARGO$",
"CARGO_CRATE_NAME": "an_example",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO": "cargo",
"CARGO_PKG_README": "",
"CARGO_PKG_REPOSITORY": "",
"CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "",
},
},
@ -208,27 +211,28 @@
),
cfg_options: CfgOptions(
[
"debug_assertions",
"rust_analyzer",
],
),
potential_cfg_options: None,
env: Env {
entries: {
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO": "$CARGO$",
"CARGO_CRATE_NAME": "it",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO": "cargo",
"CARGO_PKG_README": "",
"CARGO_PKG_REPOSITORY": "",
"CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "",
},
},
@ -274,7 +278,6 @@
),
cfg_options: CfgOptions(
[
"debug_assertions",
"feature=default",
"feature=std",
],
@ -282,7 +285,6 @@
potential_cfg_options: Some(
CfgOptions(
[
"debug_assertions",
"feature=align",
"feature=const-extern-fn",
"feature=default",
@ -295,20 +297,22 @@
),
env: Env {
entries: {
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$.cargo/registry/src/github.com-1ecc6299db9ec823/libc-0.2.98",
"CARGO_PKG_VERSION": "0.2.98",
"CARGO_PKG_AUTHORS": "",
"CARGO": "$CARGO$",
"CARGO_CRATE_NAME": "libc",
"CARGO_MANIFEST_DIR": "$ROOT$.cargo/registry/src/github.com-1ecc6299db9ec823/libc-0.2.98",
"CARGO_PKG_AUTHORS": "The Rust Project Developers",
"CARGO_PKG_DESCRIPTION": "Raw FFI bindings to platform libraries like libc.\n",
"CARGO_PKG_HOMEPAGE": "https://github.com/rust-lang/libc",
"CARGO_PKG_LICENSE": "MIT OR Apache-2.0",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_NAME": "libc",
"CARGO_PKG_VERSION_PATCH": "98",
"CARGO": "cargo",
"CARGO_PKG_REPOSITORY": "",
"CARGO_PKG_README": "README.md",
"CARGO_PKG_REPOSITORY": "https://github.com/rust-lang/libc",
"CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.2.98",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "2",
"CARGO_PKG_VERSION_PATCH": "98",
"CARGO_PKG_VERSION_PRE": "",
},
},

10
crates/project-model/test_data/output/rust_project_hello_world_project_model.txt
View File

@ -16,6 +16,7 @@
cfg_options: CfgOptions(
[
"debug_assertions",
"miri",
],
),
potential_cfg_options: None,
@ -53,6 +54,7 @@
cfg_options: CfgOptions(
[
"debug_assertions",
"miri",
],
),
potential_cfg_options: None,
@ -82,6 +84,7 @@
cfg_options: CfgOptions(
[
"debug_assertions",
"miri",
],
),
potential_cfg_options: None,
@ -111,6 +114,7 @@
cfg_options: CfgOptions(
[
"debug_assertions",
"miri",
],
),
potential_cfg_options: None,
@ -140,6 +144,7 @@
cfg_options: CfgOptions(
[
"debug_assertions",
"miri",
],
),
potential_cfg_options: None,
@ -184,6 +189,7 @@
cfg_options: CfgOptions(
[
"debug_assertions",
"miri",
],
),
potential_cfg_options: None,
@ -213,6 +219,7 @@
cfg_options: CfgOptions(
[
"debug_assertions",
"miri",
],
),
potential_cfg_options: None,
@ -299,6 +306,7 @@
cfg_options: CfgOptions(
[
"debug_assertions",
"miri",
],
),
potential_cfg_options: None,
@ -328,6 +336,7 @@
cfg_options: CfgOptions(
[
"debug_assertions",
"miri",
],
),
potential_cfg_options: None,
@ -357,6 +366,7 @@
cfg_options: CfgOptions(
[
"debug_assertions",
"miri",
],
),
potential_cfg_options: None,

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

@ -81,6 +81,7 @@ fn new() -> Result<Self> {
rustc_cfg: vec![],
toolchain: None,
target_layout: data_layout.map(Arc::from).map_err(|it| Arc::from(it.to_string())),
cfg_overrides: Default::default(),
};
let load_cargo_config = LoadCargoConfig {
load_out_dirs_from_check: false,

19
crates/rust-analyzer/src/config.rs
View File

@ -124,7 +124,12 @@
/// avoid checking unnecessary things.
cargo_buildScripts_useRustcWrapper: bool = true,
/// List of cfg options to enable with the given values.
cargo_cfgs: FxHashMap<String, String> = FxHashMap::default(),
cargo_cfgs: FxHashMap<String, Option<String>> = {
let mut m = FxHashMap::default();
m.insert("debug_assertions".to_owned(), None);
m.insert("miri".to_owned(), None);
m
},
/// Extra arguments that are passed to every cargo invocation.
cargo_extraArgs: Vec<String> = vec![],
/// Extra environment variables that will be set when running cargo, rustc
@ -1601,12 +1606,9 @@ pub fn cargo(&self) -> CargoConfig {
global: CfgDiff::new(
self.cargo_cfgs()
.iter()
.map(|(key, val)| {
if val.is_empty() {
CfgAtom::Flag(key.into())
} else {
CfgAtom::KeyValue { key: key.into(), value: val.into() }
}
.map(|(key, val)| match val {
Some(val) => CfgAtom::KeyValue { key: key.into(), value: val.into() },
None => CfgAtom::Flag(key.into()),
})
.collect(),
vec![],
@ -2678,6 +2680,9 @@ macro_rules! set {
"FxHashMap<Box<str>, usize>" => set! {
"type": "object",
},
"FxHashMap<String, Option<String>>" => set! {
"type": "object",
},
"Option<usize>" => set! {
"type": ["null", "integer"],
"minimum": 0,

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

@ -234,6 +234,7 @@ pub(crate) fn fetch_workspaces(&mut self, cause: Cause, force_crate_graph_reload
it.clone(),
cargo_config.target.as_deref(),
&cargo_config.extra_env,
&cargo_config.cfg_overrides,
))
}
})

2
crates/test-fixture/src/lib.rs
View File

@ -209,7 +209,7 @@ pub fn parse_with_proc_macros(
assert!(default_crate_root.is_none());
default_crate_root = Some(file_id);
default_cfg.extend(meta.cfg.into_iter());
default_env.extend(meta.env.iter().map(|(x, y)| (x.to_owned(), y.to_owned())));
default_env.extend_from_other(&meta.env);
}
source_change.change_file(file_id, Some(text));

10
docs/user/generated_config.adoc
View File

@ -88,10 +88,18 @@ or build-script sources change and are saved.
Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to
avoid checking unnecessary things.
--
[[rust-analyzer.cargo.cfgs]]rust-analyzer.cargo.cfgs (default: `{}`)::
[[rust-analyzer.cargo.cfgs]]rust-analyzer.cargo.cfgs::
+
--
Default:
----
{
"debug_assertions": null,
"miri": null
}
----
List of cfg options to enable with the given values.
--
[[rust-analyzer.cargo.extraArgs]]rust-analyzer.cargo.extraArgs (default: `[]`)::
+

5
editors/code/package.json
View File

@ -610,7 +610,10 @@
},
"rust-analyzer.cargo.cfgs": {
"markdownDescription": "List of cfg options to enable with the given values.",
"default": {},
"default": {
"debug_assertions": null,
"miri": null
},
"type": "object"
},
"rust-analyzer.cargo.extraArgs": {