nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-02-21 19:33:16 +00:00
Code Issues 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, pub is_proc_macro: bool,
} }
#[derive(Default, Debug, Clone, PartialEq, Eq)] #[derive(Default, Clone, PartialEq, Eq)]
pub struct Env { pub struct Env {
entries: FxHashMap<String, String>, 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)] #[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Dependency { pub struct Dependency {
pub crate_id: CrateId, pub crate_id: CrateId,
@ -331,10 +350,11 @@ impl CrateGraph {
version: Option<String>, version: Option<String>,
cfg_options: Arc<CfgOptions>, cfg_options: Arc<CfgOptions>,
potential_cfg_options: Option<Arc<CfgOptions>>, potential_cfg_options: Option<Arc<CfgOptions>>,
env: Env, mut env: Env,
is_proc_macro: bool, is_proc_macro: bool,
origin: CrateOrigin, origin: CrateOrigin,
) -> CrateId { ) -> CrateId {
env.entries.shrink_to_fit();
let data = CrateData { let data = CrateData {
root_file_id, root_file_id,
edition, edition,
@ -651,16 +671,24 @@ impl FromIterator<(String, String)> for Env {
} }
impl Env { impl Env {
pub fn set(&mut self, env: &str, value: String) { pub fn set(&mut self, env: &str, value: impl Into<String>) {
self.entries.insert(env.to_owned(), value); self.entries.insert(env.to_owned(), value.into());
} }
pub fn get(&self, env: &str) -> Option<String> { pub fn get(&self, env: &str) -> Option<String> {
self.entries.get(env).cloned() self.entries.get(env).cloned()
} }
pub fn iter(&self) -> impl Iterator<Item = (&str, &str)> { pub fn extend_from_other(&mut self, other: &Env) {
self.entries.iter().map(|(k, v)| (k.as_str(), v.as_str())) 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 @@ impl CfgOptions {
self.enabled.insert(CfgAtom::KeyValue { key, value }); 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) { pub fn apply_diff(&mut self, diff: CfgDiff) {
for atom in diff.enable { for atom in diff.enable {
self.enabled.insert(atom); self.enabled.insert(atom);

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

@ -407,8 +407,7 @@ impl ProcMacroExpander for Expander {
call_site: Span, call_site: Span,
mixed_site: Span, mixed_site: Span,
) -> Result<tt::Subtree<Span>, ProcMacroExpansionError> { ) -> 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.clone(), def_site, call_site, mixed_site) {
match self.0.expand(subtree, attrs, env, def_site, call_site, mixed_site) {
Ok(Ok(subtree)) => Ok(subtree), Ok(Ok(subtree)) => Ok(subtree),
Ok(Err(err)) => Err(ProcMacroExpansionError::Panic(err.0)), Ok(Err(err)) => Err(ProcMacroExpansionError::Panic(err.0)),
Err(err) => Err(ProcMacroExpansionError::System(err.to_string())), Err(err) => Err(ProcMacroExpansionError::System(err.to_string())),

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

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

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

@ -23,16 +23,18 @@ use serde::Deserialize;
use toolchain::Tool; use toolchain::Tool;
use crate::{ use crate::{
cfg_flag::CfgFlag, utf8_stdout, CargoConfig, CargoFeatures, CargoWorkspace, InvocationLocation, cfg::CfgFlag, utf8_stdout, CargoConfig, CargoFeatures, CargoWorkspace, InvocationLocation,
InvocationStrategy, Package, Sysroot, TargetKind, InvocationStrategy, Package, Sysroot, TargetKind,
}; };
/// Output of the build script and proc-macro building steps for a workspace.
#[derive(Debug, Default, Clone, PartialEq, Eq)] #[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct WorkspaceBuildScripts { pub struct WorkspaceBuildScripts {
outputs: ArenaMap<Package, BuildScriptOutput>, outputs: ArenaMap<Package, BuildScriptOutput>,
error: Option<String>, error: Option<String>,
} }
/// Output of the build script and proc-macro building step for a concrete package.
#[derive(Debug, Clone, Default, PartialEq, Eq)] #[derive(Debug, Clone, Default, PartialEq, Eq)]
pub(crate) struct BuildScriptOutput { pub(crate) struct BuildScriptOutput {
/// List of config flags defined by this package's build script. /// 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>, pub active_features: Vec<String>,
/// String representation of package id /// String representation of package id
pub id: String, 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] /// The contents of [package.metadata.rust-analyzer]
pub metadata: RustAnalyzerPackageMetaData, pub metadata: RustAnalyzerPackageMetaData,
} }
@ -225,6 +239,10 @@ impl TargetKind {
} }
TargetKind::Other TargetKind::Other
} }
pub fn is_executable(self) -> bool {
matches!(self, TargetKind::Bin | TargetKind::Example)
}
} }
// Deserialize helper for the cargo metadata // Deserialize helper for the cargo metadata
@ -330,6 +348,13 @@ impl CargoWorkspace {
repository, repository,
edition, edition,
metadata, metadata,
authors,
description,
homepage,
license,
license_file,
readme,
rust_version,
.. ..
} = meta_pkg; } = meta_pkg;
let meta = from_value::<PackageMetadata>(metadata).unwrap_or_default(); let meta = from_value::<PackageMetadata>(metadata).unwrap_or_default();
@ -358,6 +383,13 @@ impl CargoWorkspace {
is_member, is_member,
edition, edition,
repository, repository,
authors,
description,
homepage,
license,
license_file,
readme,
rust_version,
dependencies: Vec::new(), dependencies: Vec::new(),
features: features.into_iter().collect(), features: features.into_iter().collect(),
active_features: Vec::new(), 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"' //! rustc main.rs --cfg foo --cfg 'feature="bar"'
use std::{fmt, str::FromStr}; use std::{fmt, str::FromStr};
use cfg::CfgOptions; use cfg::{CfgDiff, CfgOptions};
use rustc_hash::FxHashMap;
use serde::Serialize; use serde::Serialize;
#[derive(Clone, Eq, PartialEq, Debug, Serialize)] #[derive(Clone, Eq, PartialEq, Debug, Serialize)]
@ -70,3 +71,27 @@ impl fmt::Display for CfgFlag {
} }
} }
} }
/// 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 build_scripts;
mod cargo_workspace; mod cargo_workspace;
mod cfg_flag; mod cfg;
mod env;
mod manifest_path; mod manifest_path;
mod project_json; mod project_json;
mod rustc_cfg; mod rustc_cfg;
@ -47,10 +48,11 @@ pub use crate::{
CargoConfig, CargoFeatures, CargoWorkspace, Package, PackageData, PackageDependency, CargoConfig, CargoFeatures, CargoWorkspace, Package, PackageData, PackageDependency,
RustLibSource, Target, TargetData, TargetKind, RustLibSource, Target, TargetData, TargetKind,
}, },
cfg::CfgOverrides,
manifest_path::ManifestPath, manifest_path::ManifestPath,
project_json::{ProjectJson, ProjectJsonData}, project_json::{ProjectJson, ProjectJsonData},
sysroot::Sysroot, sysroot::Sysroot,
workspace::{CfgOverrides, PackageRoot, ProjectWorkspace}, workspace::{FileLoader, PackageRoot, ProjectWorkspace},
}; };
#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)] #[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]

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

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

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

@ -4,7 +4,7 @@ use anyhow::Context;
use rustc_hash::FxHashMap; use rustc_hash::FxHashMap;
use toolchain::Tool; 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. /// Determines how `rustc --print cfg` is discovered and invoked.
pub(crate) enum RustcCfgConfig<'a> { 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 = get_rust_cfgs(target, extra_env, config);
let rustc_cfgs = match rustc_cfgs { 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(), rustc_cfg: Vec::new(),
toolchain: None, toolchain: None,
target_layout: Err(Arc::from("test has no data layout")), target_layout: Err(Arc::from("test has no data layout")),
cfg_overrides: Default::default(),
}; };
to_crate_graph(project_workspace) to_crate_graph(project_workspace)
} }
@ -97,6 +98,11 @@ fn get_test_json_file<T: DeserializeOwned>(file: &str) -> T {
} }
} }
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) { fn replace_root(s: &mut String, direction: bool) {
if direction { if direction {
let root = if cfg!(windows) { r#"C:\\ROOT\"# } else { "/ROOT/" }; 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) { fn check_crate_graph(crate_graph: CrateGraph, expect: ExpectFile) {
let mut crate_graph = format!("{crate_graph:#?}"); let mut crate_graph = format!("{crate_graph:#?}");
replace_root(&mut crate_graph, false); replace_root(&mut crate_graph, false);
replace_cargo(&mut crate_graph);
replace_fake_sys_root(&mut crate_graph); replace_fake_sys_root(&mut crate_graph);
expect.assert_eq(&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 //! metadata` or `rust-project.json`) into representation stored in the salsa
//! database -- `CrateGraph`. //! 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 anyhow::{format_err, Context};
use base_db::{ use base_db::{
@ -21,7 +21,8 @@ use triomphe::Arc;
use crate::{ use crate::{
build_scripts::BuildScriptOutput, build_scripts::BuildScriptOutput,
cargo_workspace::{DepKind, PackageData, RustLibSource}, 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}, project_json::{Crate, CrateArrayIdx},
rustc_cfg::{self, RustcCfgConfig}, rustc_cfg::{self, RustcCfgConfig},
sysroot::{SysrootCrate, SysrootMode}, sysroot::{SysrootCrate, SysrootMode},
@ -30,29 +31,7 @@ use crate::{
ProjectJson, ProjectManifest, Sysroot, TargetData, TargetKind, WorkspaceBuildScripts, ProjectJson, ProjectManifest, Sysroot, TargetData, TargetKind, WorkspaceBuildScripts,
}; };
/// A set of cfg-overrides per crate. pub type FileLoader<'a> = &'a mut dyn for<'b> FnMut(&'b AbsPath) -> Option<FileId>;
#[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());
};
}
}
/// `PackageRoot` describes a package root folder. /// `PackageRoot` describes a package root folder.
/// Which may be an external dependency, or a member of /// Which may be an external dependency, or a member of
@ -69,30 +48,46 @@ pub struct PackageRoot {
pub enum ProjectWorkspace { pub enum ProjectWorkspace {
/// Project workspace was discovered by running `cargo metadata` and `rustc --print sysroot`. /// Project workspace was discovered by running `cargo metadata` and `rustc --print sysroot`.
Cargo { Cargo {
/// The workspace as returned by `cargo metadata`.
cargo: CargoWorkspace, cargo: CargoWorkspace,
/// The build script results for the workspace.
build_scripts: WorkspaceBuildScripts, build_scripts: WorkspaceBuildScripts,
/// The sysroot loaded for this workspace.
sysroot: Result<Sysroot, Option<String>>, 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>>, rustc: Result<Box<(CargoWorkspace, WorkspaceBuildScripts)>, Option<String>>,
/// Holds cfg flags for the current target. We get those by running /// Holds cfg flags for the current target. We get those by running
/// `rustc --print cfg`. /// `rustc --print cfg`.
/// // FIXME: make this a per-crate map, as, eg, build.rs might have a
/// FIXME: make this a per-crate map, as, eg, build.rs might have a // different target.
/// different target.
rustc_cfg: Vec<CfgFlag>, rustc_cfg: Vec<CfgFlag>,
/// A set of cfg overrides for this workspace.
cfg_overrides: CfgOverrides, cfg_overrides: CfgOverrides,
/// The toolchain version used by this workspace.
toolchain: Option<Version>, toolchain: Option<Version>,
/// The target data layout queried for workspace.
target_layout: TargetLayoutLoadResult, target_layout: TargetLayoutLoadResult,
/// Environment variables set in the `.cargo/config` file.
cargo_config_extra_env: FxHashMap<String, String>, cargo_config_extra_env: FxHashMap<String, String>,
}, },
/// Project workspace was manually specified using a `rust-project.json` file. /// Project workspace was manually specified using a `rust-project.json` file.
Json { Json {
/// The loaded project json file.
project: ProjectJson, project: ProjectJson,
/// The sysroot loaded for this workspace.
sysroot: Result<Sysroot, Option<String>>, sysroot: Result<Sysroot, Option<String>>,
/// Holds cfg flags for the current target. We get those by running /// Holds cfg flags for the current target. We get those by running
/// `rustc --print cfg`. /// `rustc --print cfg`.
// FIXME: make this a per-crate map, as, eg, build.rs might have a
// different target.
rustc_cfg: Vec<CfgFlag>, rustc_cfg: Vec<CfgFlag>,
/// The toolchain version used by this workspace.
toolchain: Option<Version>, toolchain: Option<Version>,
/// The target data layout queried for workspace.
target_layout: TargetLayoutLoadResult, 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. // 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. // 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. /// Project with a set of disjoint files, not belonging to any particular workspace.
/// Backed by basic sysroot crates for basic completion and highlighting. /// Backed by basic sysroot crates for basic completion and highlighting.
DetachedFiles { DetachedFiles {
/// The set of detached files.
files: Vec<AbsPathBuf>, files: Vec<AbsPathBuf>,
/// The sysroot loaded for this workspace.
sysroot: Result<Sysroot, Option<String>>, sysroot: Result<Sysroot, Option<String>>,
/// Holds cfg flags for the current target. We get those by running /// Holds cfg flags for the current target. We get those by running
/// `rustc --print cfg`. /// `rustc --print cfg`.
// FIXME: make this a per-crate map, as, eg, build.rs might have a
// different target.
rustc_cfg: Vec<CfgFlag>, rustc_cfg: Vec<CfgFlag>,
/// The toolchain version used by this workspace.
toolchain: Option<Version>, toolchain: Option<Version>,
/// The target data layout queried for workspace.
target_layout: TargetLayoutLoadResult, target_layout: TargetLayoutLoadResult,
/// A set of cfg overrides for the files.
cfg_overrides: CfgOverrides,
}, },
} }
@ -150,6 +153,7 @@ impl fmt::Debug for ProjectWorkspace {
rustc_cfg, rustc_cfg,
toolchain, toolchain,
target_layout: data_layout, target_layout: data_layout,
cfg_overrides,
} => { } => {
let mut debug_struct = f.debug_struct("Json"); let mut debug_struct = f.debug_struct("Json");
debug_struct.field("n_crates", &project.n_crates()); debug_struct.field("n_crates", &project.n_crates());
@ -159,7 +163,8 @@ impl fmt::Debug for ProjectWorkspace {
debug_struct debug_struct
.field("n_rustc_cfg", &rustc_cfg.len()) .field("n_rustc_cfg", &rustc_cfg.len())
.field("toolchain", &toolchain) .field("toolchain", &toolchain)
.field("data_layout", &data_layout); .field("data_layout", &data_layout)
.field("n_cfg_overrides", &cfg_overrides.len());
debug_struct.finish() debug_struct.finish()
} }
ProjectWorkspace::DetachedFiles { ProjectWorkspace::DetachedFiles {
@ -168,6 +173,7 @@ impl fmt::Debug for ProjectWorkspace {
rustc_cfg, rustc_cfg,
toolchain, toolchain,
target_layout, target_layout,
cfg_overrides,
} => f } => f
.debug_struct("DetachedFiles") .debug_struct("DetachedFiles")
.field("n_files", &files.len()) .field("n_files", &files.len())
@ -175,6 +181,7 @@ impl fmt::Debug for ProjectWorkspace {
.field("n_rustc_cfg", &rustc_cfg.len()) .field("n_rustc_cfg", &rustc_cfg.len())
.field("toolchain", &toolchain) .field("toolchain", &toolchain)
.field("data_layout", &target_layout) .field("data_layout", &target_layout)
.field("n_cfg_overrides", &cfg_overrides.len())
.finish(), .finish(),
} }
} }
@ -228,6 +235,7 @@ impl ProjectWorkspace {
project_json, project_json,
config.target.as_deref(), config.target.as_deref(),
&config.extra_env, &config.extra_env,
&config.cfg_overrides,
) )
} }
ProjectManifest::CargoToml(cargo_toml) => { ProjectManifest::CargoToml(cargo_toml) => {
@ -369,6 +377,7 @@ impl ProjectWorkspace {
project_json: ProjectJson, project_json: ProjectJson,
target: Option<&str>, target: Option<&str>,
extra_env: &FxHashMap<String, String>, extra_env: &FxHashMap<String, String>,
cfg_overrides: &CfgOverrides,
) -> ProjectWorkspace { ) -> ProjectWorkspace {
let sysroot = match (project_json.sysroot.clone(), project_json.sysroot_src.clone()) { let sysroot = match (project_json.sysroot.clone(), project_json.sysroot_src.clone()) {
(Some(sysroot), Some(sysroot_src)) => { (Some(sysroot), Some(sysroot_src)) => {
@ -415,6 +424,7 @@ impl ProjectWorkspace {
rustc_cfg, rustc_cfg,
toolchain, toolchain,
target_layout: data_layout.map(Arc::from).map_err(|it| Arc::from(it.to_string())), target_layout: data_layout.map(Arc::from).map_err(|it| Arc::from(it.to_string())),
cfg_overrides: cfg_overrides.clone(),
} }
} }
@ -465,6 +475,7 @@ impl ProjectWorkspace {
rustc_cfg, rustc_cfg,
toolchain, toolchain,
target_layout: data_layout.map(Arc::from).map_err(|it| Arc::from(it.to_string())), 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 @@ impl ProjectWorkspace {
rustc_cfg: _, rustc_cfg: _,
toolchain: _, toolchain: _,
target_layout: _, target_layout: _,
cfg_overrides: _,
} => project } => project
.crates() .crates()
.map(|(_, krate)| PackageRoot { .map(|(_, krate)| PackageRoot {
@ -723,7 +735,7 @@ impl ProjectWorkspace {
pub fn to_crate_graph( pub fn to_crate_graph(
&self, &self,
load: &mut dyn FnMut(&AbsPath) -> Option<FileId>, load: FileLoader<'_>,
extra_env: &FxHashMap<String, String>, extra_env: &FxHashMap<String, String>,
) -> (CrateGraph, ProcMacroPaths) { ) -> (CrateGraph, ProcMacroPaths) {
let _p = tracing::span!(tracing::Level::INFO, "ProjectWorkspace::to_crate_graph").entered(); let _p = tracing::span!(tracing::Level::INFO, "ProjectWorkspace::to_crate_graph").entered();
@ -735,6 +747,7 @@ impl ProjectWorkspace {
rustc_cfg, rustc_cfg,
toolchain: _, toolchain: _,
target_layout: _, target_layout: _,
cfg_overrides,
} => ( } => (
project_json_to_crate_graph( project_json_to_crate_graph(
rustc_cfg.clone(), rustc_cfg.clone(),
@ -742,6 +755,7 @@ impl ProjectWorkspace {
project, project,
sysroot.as_ref().ok(), sysroot.as_ref().ok(),
extra_env, extra_env,
cfg_overrides,
), ),
sysroot, sysroot,
), ),
@ -773,12 +787,14 @@ impl ProjectWorkspace {
rustc_cfg, rustc_cfg,
toolchain: _, toolchain: _,
target_layout: _, target_layout: _,
cfg_overrides,
} => ( } => (
detached_files_to_crate_graph( detached_files_to_crate_graph(
rustc_cfg.clone(), rustc_cfg.clone(),
load, load,
files, files,
sysroot.as_ref().ok(), sysroot.as_ref().ok(),
cfg_overrides,
), ),
sysroot, sysroot,
), ),
@ -829,28 +845,45 @@ impl ProjectWorkspace {
&& cargo_config_extra_env == o_cargo_config_extra_env && 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 { Self::Json {
project: o_project, project: o_project,
sysroot: o_sysroot, sysroot: o_sysroot,
rustc_cfg: o_rustc_cfg, rustc_cfg: o_rustc_cfg,
toolchain: o_toolchain, toolchain: o_toolchain,
target_layout: _, target_layout: _,
cfg_overrides: o_cfg_overrides,
}, },
) => { ) => {
project == o_project project == o_project
&& rustc_cfg == o_rustc_cfg && rustc_cfg == o_rustc_cfg
&& sysroot == o_sysroot && sysroot == o_sysroot
&& toolchain == o_toolchain && 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 { Self::DetachedFiles {
files: o_files, files: o_files,
sysroot: o_sysroot, sysroot: o_sysroot,
rustc_cfg: o_rustc_cfg, rustc_cfg: o_rustc_cfg,
toolchain: o_toolchain, toolchain: o_toolchain,
target_layout: o_target_layout, target_layout: o_target_layout,
cfg_overrides: o_cfg_overrides,
}, },
) => { ) => {
files == o_files files == o_files
@ -858,6 +891,7 @@ impl ProjectWorkspace {
&& rustc_cfg == o_rustc_cfg && rustc_cfg == o_rustc_cfg
&& toolchain == o_toolchain && toolchain == o_toolchain
&& target_layout == o_target_layout && target_layout == o_target_layout
&& cfg_overrides == o_cfg_overrides
} }
_ => false, _ => false,
} }
@ -874,10 +908,11 @@ impl ProjectWorkspace {
fn project_json_to_crate_graph( fn project_json_to_crate_graph(
rustc_cfg: Vec<CfgFlag>, rustc_cfg: Vec<CfgFlag>,
load: &mut dyn FnMut(&AbsPath) -> Option<FileId>, load: FileLoader<'_>,
project: &ProjectJson, project: &ProjectJson,
sysroot: Option<&Sysroot>, sysroot: Option<&Sysroot>,
extra_env: &FxHashMap<String, String>, extra_env: &FxHashMap<String, String>,
override_cfg: &CfgOverrides,
) -> (CrateGraph, ProcMacroPaths) { ) -> (CrateGraph, ProcMacroPaths) {
let mut res = (CrateGraph::default(), ProcMacroPaths::default()); let mut res = (CrateGraph::default(), ProcMacroPaths::default());
let (crate_graph, proc_macros) = &mut res; let (crate_graph, proc_macros) = &mut res;
@ -917,19 +952,22 @@ fn project_json_to_crate_graph(
None => &rustc_cfg, 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( let crate_graph_crate_id = crate_graph.add_crate_root(
file_id, file_id,
*edition, *edition,
display_name.clone(), display_name.clone(),
version.clone(), version.clone(),
Arc::new( Arc::new(cfg_options),
target_cfgs
.iter()
.chain(cfg.iter())
.chain(iter::once(&r_a_cfg_flag))
.cloned()
.collect(),
),
None, None,
env, env,
*is_proc_macro, *is_proc_macro,
@ -976,7 +1014,7 @@ fn project_json_to_crate_graph(
} }
fn cargo_to_crate_graph( fn cargo_to_crate_graph(
load: &mut dyn FnMut(&AbsPath) -> Option<FileId>, load: FileLoader<'_>,
rustc: Option<&(CargoWorkspace, WorkspaceBuildScripts)>, rustc: Option<&(CargoWorkspace, WorkspaceBuildScripts)>,
cargo: &CargoWorkspace, cargo: &CargoWorkspace,
sysroot: Option<&Sysroot>, sysroot: Option<&Sysroot>,
@ -993,7 +1031,7 @@ fn cargo_to_crate_graph(
None => (SysrootPublicDeps::default(), None), 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 // Mapping of a package to its library target
let mut pkg_to_lib_crate = FxHashMap::default(); let mut pkg_to_lib_crate = FxHashMap::default();
@ -1166,9 +1204,10 @@ fn cargo_to_crate_graph(
fn detached_files_to_crate_graph( fn detached_files_to_crate_graph(
rustc_cfg: Vec<CfgFlag>, rustc_cfg: Vec<CfgFlag>,
load: &mut dyn FnMut(&AbsPath) -> Option<FileId>, load: FileLoader<'_>,
detached_files: &[AbsPathBuf], detached_files: &[AbsPathBuf],
sysroot: Option<&Sysroot>, sysroot: Option<&Sysroot>,
override_cfg: &CfgOverrides,
) -> (CrateGraph, ProcMacroPaths) { ) -> (CrateGraph, ProcMacroPaths) {
let _p = tracing::span!(tracing::Level::INFO, "detached_files_to_crate_graph").entered(); let _p = tracing::span!(tracing::Level::INFO, "detached_files_to_crate_graph").entered();
let mut crate_graph = CrateGraph::default(); let mut crate_graph = CrateGraph::default();
@ -1177,8 +1216,10 @@ fn detached_files_to_crate_graph(
None => (SysrootPublicDeps::default(), None), 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()); cfg_options.insert_atom("rust_analyzer".into());
override_cfg.apply(&mut cfg_options, "");
let cfg_options = Arc::new(cfg_options); let cfg_options = Arc::new(cfg_options);
for detached_file in detached_files { for detached_file in detached_files {
@ -1216,7 +1257,7 @@ fn handle_rustc_crates(
crate_graph: &mut CrateGraph, crate_graph: &mut CrateGraph,
proc_macros: &mut ProcMacroPaths, proc_macros: &mut ProcMacroPaths,
pkg_to_lib_crate: &mut FxHashMap<Package, CrateId>, pkg_to_lib_crate: &mut FxHashMap<Package, CrateId>,
load: &mut dyn FnMut(&AbsPath) -> Option<FileId>, load: FileLoader<'_>,
rustc_workspace: &CargoWorkspace, rustc_workspace: &CargoWorkspace,
cargo: &CargoWorkspace, cargo: &CargoWorkspace,
public_deps: &SysrootPublicDeps, public_deps: &SysrootPublicDeps,
@ -1350,23 +1391,19 @@ fn add_target_crate_root(
}; };
let mut env = Env::default(); let mut env = Env::default();
inject_cargo_env(pkg, &mut env); inject_cargo_package_env(&mut env, pkg);
if let Ok(cname) = String::from_str(cargo_name) { inject_cargo_env(&mut env);
// 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. inject_rustc_tool_env(&mut env, cargo_name, kind);
env.set("CARGO_CRATE_NAME", cname.replace('-', "_"));
}
if let Some(envs) = build_data.map(|it| &it.envs) { if let Some(envs) = build_data.map(|it| &it.envs) {
for (k, v) in envs { for (k, v) in envs {
env.set(k, v.clone()); env.set(k, v.clone());
} }
} }
let display_name = CrateDisplayName::from_canonical_name(cargo_name.to_owned());
let crate_id = crate_graph.add_crate_root( let crate_id = crate_graph.add_crate_root(
file_id, file_id,
edition, edition,
Some(display_name), Some(CrateDisplayName::from_canonical_name(cargo_name.to_owned())),
Some(pkg.version.to_string()), Some(pkg.version.to_string()),
Arc::new(cfg_options), Arc::new(cfg_options),
potential_cfg_options.map(Arc::new), potential_cfg_options.map(Arc::new),
@ -1405,7 +1442,7 @@ fn sysroot_to_crate_graph(
crate_graph: &mut CrateGraph, crate_graph: &mut CrateGraph,
sysroot: &Sysroot, sysroot: &Sysroot,
rustc_cfg: Vec<CfgFlag>, rustc_cfg: Vec<CfgFlag>,
load: &mut dyn FnMut(&AbsPath) -> Option<FileId>, load: FileLoader<'_>,
) -> (SysrootPublicDeps, Option<CrateId>) { ) -> (SysrootPublicDeps, Option<CrateId>) {
let _p = tracing::span!(tracing::Level::INFO, "sysroot_to_crate_graph").entered(); let _p = tracing::span!(tracing::Level::INFO, "sysroot_to_crate_graph").entered();
match sysroot.mode() { match sysroot.mode() {
@ -1416,7 +1453,17 @@ fn sysroot_to_crate_graph(
cargo, cargo,
None, None,
rustc_cfg, rustc_cfg,
&CfgOverrides::default(), &CfgOverrides {
global: CfgDiff::new(
vec![
CfgAtom::Flag("debug_assertions".into()),
CfgAtom::Flag("miri".into()),
],
vec![],
)
.unwrap(),
..Default::default()
},
&WorkspaceBuildScripts::default(), &WorkspaceBuildScripts::default(),
); );
@ -1474,13 +1521,18 @@ fn sysroot_to_crate_graph(
(SysrootPublicDeps { deps: pub_deps }, libproc_macro) (SysrootPublicDeps { deps: pub_deps }, libproc_macro)
} }
SysrootMode::Stitched(stitched) => { 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 let sysroot_crates: FxHashMap<SysrootCrate, CrateId> = stitched
.crates() .crates()
.filter_map(|krate| { .filter_map(|krate| {
let file_id = load(&stitched[krate].root)?; let file_id = load(&stitched[krate].root)?;
let env = Env::default();
let display_name = let display_name =
CrateDisplayName::from_canonical_name(stitched[krate].name.clone()); CrateDisplayName::from_canonical_name(stitched[krate].name.clone());
let crate_id = crate_graph.add_crate_root( let crate_id = crate_graph.add_crate_root(
@ -1490,7 +1542,7 @@ fn sysroot_to_crate_graph(
None, None,
cfg_options.clone(), cfg_options.clone(),
None, None,
env, Env::default(),
false, false,
CrateOrigin::Lang(LangCrateOrigin::from(&*stitched[krate].name)), 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) 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( cfg_options: CfgOptions(
[ [
"debug_assertions",
"rust_analyzer", "rust_analyzer",
"test", "test",
], ],
@ -25,20 +24,22 @@
potential_cfg_options: None, potential_cfg_options: None,
env: Env { env: Env {
entries: { entries: {
"CARGO_PKG_LICENSE": "", "CARGO": "$CARGO$",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO_CRATE_NAME": "hello_world", "CARGO_CRATE_NAME": "hello_world",
"CARGO_PKG_LICENSE_FILE": "", "CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_HOMEPAGE": "", "CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "", "CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world", "CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0", "CARGO_PKG_README": "",
"CARGO": "cargo",
"CARGO_PKG_REPOSITORY": "", "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_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "", "CARGO_PKG_VERSION_PRE": "",
}, },
}, },
@ -77,7 +78,6 @@
), ),
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions",
"rust_analyzer", "rust_analyzer",
"test", "test",
], ],
@ -85,20 +85,22 @@
potential_cfg_options: None, potential_cfg_options: None,
env: Env { env: Env {
entries: { entries: {
"CARGO_PKG_LICENSE": "", "CARGO": "$CARGO$",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO_CRATE_NAME": "hello_world", "CARGO_CRATE_NAME": "hello_world",
"CARGO_PKG_LICENSE_FILE": "", "CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_HOMEPAGE": "", "CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "", "CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world", "CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0", "CARGO_PKG_README": "",
"CARGO": "cargo",
"CARGO_PKG_REPOSITORY": "", "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_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "", "CARGO_PKG_VERSION_PRE": "",
}, },
}, },
@ -144,7 +146,6 @@
), ),
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions",
"rust_analyzer", "rust_analyzer",
"test", "test",
], ],
@ -152,20 +153,22 @@
potential_cfg_options: None, potential_cfg_options: None,
env: Env { env: Env {
entries: { entries: {
"CARGO_PKG_LICENSE": "", "CARGO": "$CARGO$",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO_CRATE_NAME": "an_example", "CARGO_CRATE_NAME": "an_example",
"CARGO_PKG_LICENSE_FILE": "", "CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_HOMEPAGE": "", "CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "", "CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world", "CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0", "CARGO_PKG_README": "",
"CARGO": "cargo",
"CARGO_PKG_REPOSITORY": "", "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_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "", "CARGO_PKG_VERSION_PRE": "",
}, },
}, },
@ -211,7 +214,6 @@
), ),
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions",
"rust_analyzer", "rust_analyzer",
"test", "test",
], ],
@ -219,20 +221,22 @@
potential_cfg_options: None, potential_cfg_options: None,
env: Env { env: Env {
entries: { entries: {
"CARGO_PKG_LICENSE": "", "CARGO": "$CARGO$",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO_CRATE_NAME": "it", "CARGO_CRATE_NAME": "it",
"CARGO_PKG_LICENSE_FILE": "", "CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_HOMEPAGE": "", "CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "", "CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world", "CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0", "CARGO_PKG_README": "",
"CARGO": "cargo",
"CARGO_PKG_REPOSITORY": "", "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_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "", "CARGO_PKG_VERSION_PRE": "",
}, },
}, },
@ -278,7 +282,6 @@
), ),
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions",
"feature=default", "feature=default",
"feature=std", "feature=std",
], ],
@ -286,7 +289,6 @@
potential_cfg_options: Some( potential_cfg_options: Some(
CfgOptions( CfgOptions(
[ [
"debug_assertions",
"feature=align", "feature=align",
"feature=const-extern-fn", "feature=const-extern-fn",
"feature=default", "feature=default",
@ -299,20 +301,22 @@
), ),
env: Env { env: Env {
entries: { entries: {
"CARGO_PKG_LICENSE": "", "CARGO": "$CARGO$",
"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_CRATE_NAME": "libc", "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_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_NAME": "libc", "CARGO_PKG_NAME": "libc",
"CARGO_PKG_VERSION_PATCH": "98", "CARGO_PKG_README": "README.md",
"CARGO": "cargo", "CARGO_PKG_REPOSITORY": "https://github.com/rust-lang/libc",
"CARGO_PKG_REPOSITORY": "", "CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.2.98",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "2", "CARGO_PKG_VERSION_MINOR": "2",
"CARGO_PKG_VERSION_PATCH": "98",
"CARGO_PKG_VERSION_PRE": "", "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( cfg_options: CfgOptions(
[ [
"debug_assertions",
"rust_analyzer", "rust_analyzer",
"test", "test",
], ],
@ -25,20 +24,22 @@
potential_cfg_options: None, potential_cfg_options: None,
env: Env { env: Env {
entries: { entries: {
"CARGO_PKG_LICENSE": "", "CARGO": "$CARGO$",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO_CRATE_NAME": "hello_world", "CARGO_CRATE_NAME": "hello_world",
"CARGO_PKG_LICENSE_FILE": "", "CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_HOMEPAGE": "", "CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "", "CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world", "CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0", "CARGO_PKG_README": "",
"CARGO": "cargo",
"CARGO_PKG_REPOSITORY": "", "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_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "", "CARGO_PKG_VERSION_PRE": "",
}, },
}, },
@ -77,7 +78,6 @@
), ),
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions",
"rust_analyzer", "rust_analyzer",
"test", "test",
], ],
@ -85,20 +85,22 @@
potential_cfg_options: None, potential_cfg_options: None,
env: Env { env: Env {
entries: { entries: {
"CARGO_PKG_LICENSE": "", "CARGO": "$CARGO$",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO_CRATE_NAME": "hello_world", "CARGO_CRATE_NAME": "hello_world",
"CARGO_PKG_LICENSE_FILE": "", "CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_HOMEPAGE": "", "CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "", "CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world", "CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0", "CARGO_PKG_README": "",
"CARGO": "cargo",
"CARGO_PKG_REPOSITORY": "", "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_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "", "CARGO_PKG_VERSION_PRE": "",
}, },
}, },
@ -144,7 +146,6 @@
), ),
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions",
"rust_analyzer", "rust_analyzer",
"test", "test",
], ],
@ -152,20 +153,22 @@
potential_cfg_options: None, potential_cfg_options: None,
env: Env { env: Env {
entries: { entries: {
"CARGO_PKG_LICENSE": "", "CARGO": "$CARGO$",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO_CRATE_NAME": "an_example", "CARGO_CRATE_NAME": "an_example",
"CARGO_PKG_LICENSE_FILE": "", "CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_HOMEPAGE": "", "CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "", "CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world", "CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0", "CARGO_PKG_README": "",
"CARGO": "cargo",
"CARGO_PKG_REPOSITORY": "", "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_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "", "CARGO_PKG_VERSION_PRE": "",
}, },
}, },
@ -211,7 +214,6 @@
), ),
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions",
"rust_analyzer", "rust_analyzer",
"test", "test",
], ],
@ -219,20 +221,22 @@
potential_cfg_options: None, potential_cfg_options: None,
env: Env { env: Env {
entries: { entries: {
"CARGO_PKG_LICENSE": "", "CARGO": "$CARGO$",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO_CRATE_NAME": "it", "CARGO_CRATE_NAME": "it",
"CARGO_PKG_LICENSE_FILE": "", "CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_HOMEPAGE": "", "CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "", "CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world", "CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0", "CARGO_PKG_README": "",
"CARGO": "cargo",
"CARGO_PKG_REPOSITORY": "", "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_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "", "CARGO_PKG_VERSION_PRE": "",
}, },
}, },
@ -278,7 +282,6 @@
), ),
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions",
"feature=default", "feature=default",
"feature=std", "feature=std",
], ],
@ -286,7 +289,6 @@
potential_cfg_options: Some( potential_cfg_options: Some(
CfgOptions( CfgOptions(
[ [
"debug_assertions",
"feature=align", "feature=align",
"feature=const-extern-fn", "feature=const-extern-fn",
"feature=default", "feature=default",
@ -299,20 +301,22 @@
), ),
env: Env { env: Env {
entries: { entries: {
"CARGO_PKG_LICENSE": "", "CARGO": "$CARGO$",
"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_CRATE_NAME": "libc", "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_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_NAME": "libc", "CARGO_PKG_NAME": "libc",
"CARGO_PKG_VERSION_PATCH": "98", "CARGO_PKG_README": "README.md",
"CARGO": "cargo", "CARGO_PKG_REPOSITORY": "https://github.com/rust-lang/libc",
"CARGO_PKG_REPOSITORY": "", "CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.2.98",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "2", "CARGO_PKG_VERSION_MINOR": "2",
"CARGO_PKG_VERSION_PATCH": "98",
"CARGO_PKG_VERSION_PRE": "", "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( cfg_options: CfgOptions(
[ [
"debug_assertions",
"rust_analyzer", "rust_analyzer",
], ],
), ),
potential_cfg_options: None, potential_cfg_options: None,
env: Env { env: Env {
entries: { entries: {
"CARGO_PKG_LICENSE": "", "CARGO": "$CARGO$",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO_CRATE_NAME": "hello_world", "CARGO_CRATE_NAME": "hello_world",
"CARGO_PKG_LICENSE_FILE": "", "CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_HOMEPAGE": "", "CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "", "CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world", "CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0", "CARGO_PKG_README": "",
"CARGO": "cargo",
"CARGO_PKG_REPOSITORY": "", "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_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "", "CARGO_PKG_VERSION_PRE": "",
}, },
}, },
@ -76,27 +77,28 @@
), ),
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions",
"rust_analyzer", "rust_analyzer",
], ],
), ),
potential_cfg_options: None, potential_cfg_options: None,
env: Env { env: Env {
entries: { entries: {
"CARGO_PKG_LICENSE": "", "CARGO": "$CARGO$",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO_CRATE_NAME": "hello_world", "CARGO_CRATE_NAME": "hello_world",
"CARGO_PKG_LICENSE_FILE": "", "CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_HOMEPAGE": "", "CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "", "CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world", "CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0", "CARGO_PKG_README": "",
"CARGO": "cargo",
"CARGO_PKG_REPOSITORY": "", "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_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "", "CARGO_PKG_VERSION_PRE": "",
}, },
}, },
@ -142,27 +144,28 @@
), ),
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions",
"rust_analyzer", "rust_analyzer",
], ],
), ),
potential_cfg_options: None, potential_cfg_options: None,
env: Env { env: Env {
entries: { entries: {
"CARGO_PKG_LICENSE": "", "CARGO": "$CARGO$",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO_CRATE_NAME": "an_example", "CARGO_CRATE_NAME": "an_example",
"CARGO_PKG_LICENSE_FILE": "", "CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_HOMEPAGE": "", "CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "", "CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world", "CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0", "CARGO_PKG_README": "",
"CARGO": "cargo",
"CARGO_PKG_REPOSITORY": "", "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_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "", "CARGO_PKG_VERSION_PRE": "",
}, },
}, },
@ -208,27 +211,28 @@
), ),
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions",
"rust_analyzer", "rust_analyzer",
], ],
), ),
potential_cfg_options: None, potential_cfg_options: None,
env: Env { env: Env {
entries: { entries: {
"CARGO_PKG_LICENSE": "", "CARGO": "$CARGO$",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_VERSION": "0.1.0",
"CARGO_PKG_AUTHORS": "",
"CARGO_CRATE_NAME": "it", "CARGO_CRATE_NAME": "it",
"CARGO_PKG_LICENSE_FILE": "", "CARGO_MANIFEST_DIR": "$ROOT$hello-world",
"CARGO_PKG_HOMEPAGE": "", "CARGO_PKG_AUTHORS": "",
"CARGO_PKG_DESCRIPTION": "", "CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_LICENSE": "",
"CARGO_PKG_LICENSE_FILE": "",
"CARGO_PKG_NAME": "hello-world", "CARGO_PKG_NAME": "hello-world",
"CARGO_PKG_VERSION_PATCH": "0", "CARGO_PKG_README": "",
"CARGO": "cargo",
"CARGO_PKG_REPOSITORY": "", "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_MINOR": "1",
"CARGO_PKG_VERSION_PATCH": "0",
"CARGO_PKG_VERSION_PRE": "", "CARGO_PKG_VERSION_PRE": "",
}, },
}, },
@ -274,7 +278,6 @@
), ),
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions",
"feature=default", "feature=default",
"feature=std", "feature=std",
], ],
@ -282,7 +285,6 @@
potential_cfg_options: Some( potential_cfg_options: Some(
CfgOptions( CfgOptions(
[ [
"debug_assertions",
"feature=align", "feature=align",
"feature=const-extern-fn", "feature=const-extern-fn",
"feature=default", "feature=default",
@ -295,20 +297,22 @@
), ),
env: Env { env: Env {
entries: { entries: {
"CARGO_PKG_LICENSE": "", "CARGO": "$CARGO$",
"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_CRATE_NAME": "libc", "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_LICENSE_FILE": "",
"CARGO_PKG_HOMEPAGE": "",
"CARGO_PKG_DESCRIPTION": "",
"CARGO_PKG_NAME": "libc", "CARGO_PKG_NAME": "libc",
"CARGO_PKG_VERSION_PATCH": "98", "CARGO_PKG_README": "README.md",
"CARGO": "cargo", "CARGO_PKG_REPOSITORY": "https://github.com/rust-lang/libc",
"CARGO_PKG_REPOSITORY": "", "CARGO_PKG_RUST_VERSION": "",
"CARGO_PKG_VERSION": "0.2.98",
"CARGO_PKG_VERSION_MAJOR": "0",
"CARGO_PKG_VERSION_MINOR": "2", "CARGO_PKG_VERSION_MINOR": "2",
"CARGO_PKG_VERSION_PATCH": "98",
"CARGO_PKG_VERSION_PRE": "", "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( cfg_options: CfgOptions(
[ [
"debug_assertions", "debug_assertions",
"miri",
], ],
), ),
potential_cfg_options: None, potential_cfg_options: None,
@ -53,6 +54,7 @@
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions", "debug_assertions",
"miri",
], ],
), ),
potential_cfg_options: None, potential_cfg_options: None,
@ -82,6 +84,7 @@
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions", "debug_assertions",
"miri",
], ],
), ),
potential_cfg_options: None, potential_cfg_options: None,
@ -111,6 +114,7 @@
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions", "debug_assertions",
"miri",
], ],
), ),
potential_cfg_options: None, potential_cfg_options: None,
@ -140,6 +144,7 @@
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions", "debug_assertions",
"miri",
], ],
), ),
potential_cfg_options: None, potential_cfg_options: None,
@ -184,6 +189,7 @@
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions", "debug_assertions",
"miri",
], ],
), ),
potential_cfg_options: None, potential_cfg_options: None,
@ -213,6 +219,7 @@
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions", "debug_assertions",
"miri",
], ],
), ),
potential_cfg_options: None, potential_cfg_options: None,
@ -299,6 +306,7 @@
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions", "debug_assertions",
"miri",
], ],
), ),
potential_cfg_options: None, potential_cfg_options: None,
@ -328,6 +336,7 @@
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions", "debug_assertions",
"miri",
], ],
), ),
potential_cfg_options: None, potential_cfg_options: None,
@ -357,6 +366,7 @@
cfg_options: CfgOptions( cfg_options: CfgOptions(
[ [
"debug_assertions", "debug_assertions",
"miri",
], ],
), ),
potential_cfg_options: None, potential_cfg_options: None,

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

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

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

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

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

@ -234,6 +234,7 @@ impl GlobalState {
it.clone(), it.clone(),
cargo_config.target.as_deref(), cargo_config.target.as_deref(),
&cargo_config.extra_env, &cargo_config.extra_env,
&cargo_config.cfg_overrides,
)) ))
} }
}) })

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

@ -209,7 +209,7 @@ impl ChangeFixture {
assert!(default_crate_root.is_none()); assert!(default_crate_root.is_none());
default_crate_root = Some(file_id); default_crate_root = Some(file_id);
default_cfg.extend(meta.cfg.into_iter()); 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)); 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 Use `RUSTC_WRAPPER=rust-analyzer` when running build scripts to
avoid checking unnecessary things. 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. List of cfg options to enable with the given values.
-- --
[[rust-analyzer.cargo.extraArgs]]rust-analyzer.cargo.extraArgs (default: `[]`):: [[rust-analyzer.cargo.extraArgs]]rust-analyzer.cargo.extraArgs (default: `[]`)::
+ +

5
editors/code/package.json
View File

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