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

internal: Cleanup cfg and env handling in project-model
Fixesrust-lang/rust-analyzer#16122 (comment)
`miri` and `debug_assertions` are now enabled via the `cargo.cfgs` config by default, allowing them to be disabled by overwriting the config.

Author: bors

crates/base-db/src/input.rs

@@ -295,11 +295,30 @@ pub struct CrateData {
 pubis_proc_macro:bool,
 }
 
-#[derive(Default,Debug,Clone,PartialEq,Eq)]
+#[derive(Default,Clone,PartialEq,Eq)]
 pubstructEnv{
 entries:FxHashMap<String,String>,
 }
 
+impl fmt::DebugforEnv{
+fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
+structEnvDebug<'s>(Vec<(&'sString,&'sString)>);
+
+impl fmt::DebugforEnvDebug<'_>{
+fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
+ f.debug_map().entries(self.0.iter().copied()).finish()
+}
+}
+ f.debug_struct("Env")
+.field("entries",&{
+letmut entries:Vec<_> = self.entries.iter().collect();
+ entries.sort();
+EnvDebug(entries)
+})
+.finish()
+}
+}
+
 #[derive(Debug,Clone,PartialEq,Eq,Hash)]
 pubstructDependency{
 pubcrate_id:CrateId,
@@ -331,10 +350,11 @@ impl CrateGraph {
 version:Option<String>,
 cfg_options:Arc<CfgOptions>,
 potential_cfg_options:Option<Arc<CfgOptions>>,
-env:Env,
+mutenv:Env,
 is_proc_macro:bool,
 origin:CrateOrigin,
 ) -> CrateId{
+ env.entries.shrink_to_fit();
 let data = CrateData{
  root_file_id,
  edition,
@@ -651,16 +671,24 @@ impl FromIterator<(String, String)> for Env {
 }
 
 implEnv{
-pubfnset(&mutself,env:&str,value:String){
-self.entries.insert(env.to_owned(), value);
+pubfnset(&mutself,env:&str,value:implInto<String>){
+self.entries.insert(env.to_owned(), value.into());
 }
 
 pubfnget(&self,env:&str) -> Option<String>{
 self.entries.get(env).cloned()
 }
 
-pubfniter(&self) -> implIterator<Item = (&str,&str)>{
-self.entries.iter().map(|(k, v)| (k.as_str(), v.as_str()))
+pubfnextend_from_other(&mutself,other:&Env){
+self.entries.extend(other.entries.iter().map(|(x, y)| (x.to_owned(), y.to_owned())));
+}
+}
+
+implFrom<Env>forVec<(String,String)>{
+fnfrom(env:Env) -> Vec<(String,String)>{
+letmut entries:Vec<_> = env.entries.into_iter().collect();
+ entries.sort();
+ entries
 }
 }
 

crates/cfg/src/lib.rs

@@ -58,13 +58,6 @@ impl CfgOptions {
 self.enabled.insert(CfgAtom::KeyValue{ key, value });
 }
 
-pubfndifference<'a>(
-&'aself,
-other:&'aCfgOptions,
-) -> implIterator<Item = &'aCfgAtom> + 'a{
-self.enabled.difference(&other.enabled)
-}
-
 pubfnapply_diff(&mutself,diff:CfgDiff){
 for atom in diff.enable{
 self.enabled.insert(atom);

crates/load-cargo/src/lib.rs

@@ -407,8 +407,7 @@ impl ProcMacroExpander for Expander {
 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();
-matchself.0.expand(subtree, attrs, env, def_site, call_site, mixed_site){
+matchself.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())),

crates/proc-macro-api/src/lib.rs

@@ -11,6 +11,7 @@ pub mod msg;
 mod process;
 mod version;
 
+use base_db::Env;
 use indexmap::IndexSet;
 use paths::AbsPathBuf;
 use rustc_hash::FxHashMap;
@@ -152,16 +153,13 @@ impl ProcMacro {
 &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");
 
 letmut span_data_table = IndexSet::default();
 let def_site = span_data_table.insert_full(def_site).0;
@@ -172,7 +170,7 @@ impl ProcMacro {
 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,

crates/project-model/src/build_scripts.rs

@@ -23,16 +23,18 @@ use serde::Deserialize;
 use toolchain::Tool;
 
 usecrate::{
-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)]
 pubstructWorkspaceBuildScripts{
 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)structBuildScriptOutput{
 /// List of config flags defined by this package's build script.

crates/project-model/src/cargo_workspace.rs

@@ -135,6 +135,20 @@ pub struct PackageData {
 pubactive_features:Vec<String>,
 /// String representation of package id
 pubid:String,
+/// Authors as given in the `Cargo.toml`
+pubauthors:Vec<String>,
+/// Description as given in the `Cargo.toml`
+pubdescription:Option<String>,
+/// Homepage as given in the `Cargo.toml`
+pubhomepage:Option<String>,
+/// License as given in the `Cargo.toml`
+publicense:Option<String>,
+/// License file as given in the `Cargo.toml`
+publicense_file:Option<Utf8PathBuf>,
+/// Readme file as given in the `Cargo.toml`
+pubreadme:Option<Utf8PathBuf>,
+/// Rust version as given in the `Cargo.toml`
+pubrust_version:Option<semver::Version>,
 /// The contents of [package.metadata.rust-analyzer]
 pubmetadata:RustAnalyzerPackageMetaData,
 }
@@ -225,6 +239,10 @@ impl TargetKind {
 }
 TargetKind::Other
 }
+
+pubfnis_executable(self) -> bool{
+matches!(self,TargetKind::Bin | TargetKind::Example)
+}
 }
 
 // Deserialize helper for the cargo metadata
@@ -330,6 +348,13 @@ impl 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 @@ impl 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(),

crates/project-model/src/cfg_flag.rs crates/project-model/src/cfg.rscrates/project-model/src/cfg_flag.rs renamed to crates/project-model/src/cfg.rs

@@ -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 @@ impl fmt::Display for CfgFlag {
 }
 }
 }
+
+/// A set of cfg-overrides per crate.
+#[derive(Default,Debug,Clone,Eq,PartialEq)]
+pubstructCfgOverrides{
+/// A global set of overrides matching all crates.
+pubglobal:CfgDiff,
+/// A set of overrides matching specific crates.
+pubselective:FxHashMap<String,CfgDiff>,
+}
+
+implCfgOverrides{
+pubfnlen(&self) -> usize{
+self.global.len() + self.selective.values().map(|it| it.len()).sum::<usize>()
+}
+
+pubfnapply(&self,cfg_options:&mutCfgOptions,name:&str){
+if !self.global.is_empty(){
+ cfg_options.apply_diff(self.global.clone());
+};
+ifletSome(diff) = self.selective.get(name){
+ cfg_options.apply_diff(diff.clone());
+};
+}
+}

crates/project-model/src/env.rs

@@ -0,0 +1,85 @@
+//! Cargo-like environment variables injection.
+use base_db::Env;
+use rustc_hash::FxHashMap;
+use toolchain::Tool;
+
+usecrate::{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)fninject_cargo_package_env(env:&mutEnv,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)fninject_cargo_env(env:&mutEnv){
+ env.set("CARGO",Tool::Cargo.path().to_string());
+}
+
+pub(crate)fninject_rustc_tool_env(env:&mutEnv,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)fncargo_config_env(
+cargo_toml:&ManifestPath,
+extra_env:&FxHashMap<String,String>,
+sysroot:Option<&Sysroot>,
+) -> FxHashMap<String,String>{
+letmut 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()
+}
+
+fnparse_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()
+}

crates/project-model/src/lib.rs

@@ -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 @@ pub use crate::{
 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)]

crates/project-model/src/project_json.rs

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