-use std::{collections::VecDeque, fmt, fs, iter, str::FromStr, sync};

- cfg_flag::CfgFlag,

- project_json::Crate,

-/// 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>()

- }

-}

- ///

- /// FIXME: make this a per-crate map, as, eg, build.rs might have a

- /// different target.

- DetachedFiles {

- files: Vec<AbsPathBuf>,

- .field("data_layout", &data_layout);

- ProjectWorkspace::DetachedFiles {

- files,

- .field("n_files", &files.len())

- ) -> anyhow::Result<ProjectWorkspace> {

- let dir = detached_files

- .first()

- .and_then(|it| it.parent())

- .ok_or_else(|| format_err!("No detached files to load"))?;

- let sysroot = match &config.sysroot {

- Some(RustLibSource::Path(path)) => {

- Sysroot::with_sysroot_dir(path.clone(), config.sysroot_query_metadata)

- .map_err(|e| Some(format!("Failed to find sysroot at {path}:{e}")))

- }

- Some(RustLibSource::Discover) => Sysroot::discover(

- dir,

- &config.extra_env,

- config.sysroot_query_metadata,

- )

- .map_err(|e| {

- Some(format!("Failed to find sysroot for {dir}. Is rust-src installed? {e}"))

- }),

- None => Err(None),

- };

- let sysroot_ref = sysroot.as_ref().ok();

- let toolchain =

- match get_toolchain_version(dir, sysroot_ref, Tool::Rustc, &config.extra_env, "rustc ")

- {

- Ok(it) => it,

- Err(e) => {

- tracing::error!("{e}");

- None

- }

- };

- let rustc_cfg = rustc_cfg::get(None, &config.extra_env, RustcCfgConfig::Rustc(sysroot_ref));

- let data_layout = target_data_layout::get(

- RustcDataLayoutConfig::Rustc(sysroot_ref),

- None,

- &config.extra_env,

- );

- Ok(ProjectWorkspace::DetachedFiles {

- files: detached_files,

- sysroot,

- rustc_cfg,

- toolchain,

- target_layout: data_layout.map(Arc::from).map_err(|it| Arc::from(it.to_string())),

- })

- ProjectWorkspace::Cargo { cargo, toolchain, sysroot, .. } => {

- ProjectWorkspace::Json { .. } | ProjectWorkspace::DetachedFiles { .. } => {

- Ok(WorkspaceBuildScripts::default())

- }

- pub fn workspace_definition_path(&self) -> Option<&AbsPath> {

- ProjectWorkspace::Cargo { cargo, .. } => Some(cargo.workspace_root()),

- ProjectWorkspace::Json { project, .. } => Some(project.path()),

- ProjectWorkspace::DetachedFiles { .. } => None,

- | ProjectWorkspace::DetachedFiles { sysroot: Ok(sysroot), .. } => {

- ProjectWorkspace::DetachedFiles { .. } => {

- ProjectWorkspace::DetachedFiles { files, sysroot, .. } => files

- .iter()

- .map(|detached_file| PackageRoot {

- include: vec![detached_file.clone()],

- .collect(),

- ProjectWorkspace::DetachedFiles { sysroot, files, .. } => {

- sysroot_package_len + files.len()

- load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,

- ProjectWorkspace::DetachedFiles {

- files,

- detached_files_to_crate_graph(

- rustc_cfg.clone(),

- load,

- files,

- sysroot.as_ref().ok(),

- ),

- if matches!(sysroot.as_ref().map(|it| it.mode()), Ok(SysrootMode::Workspace(_)))

- Self::Json { project, sysroot, rustc_cfg, toolchain, target_layout: _ },

- Self::DetachedFiles { files, sysroot, rustc_cfg, toolchain, target_layout },

- Self::DetachedFiles {

- files: o_files,

- files == o_files

- load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,

- let crates: FxHashMap<CrateId, CrateId> = project

- .filter_map(|(crate_id, krate)| Some((crate_id, krate, load(&krate.root_module)?)))

- crate_id,

- target_cfgs

- .iter()

- .chain(cfg.iter())

- .chain(iter::once(&r_a_cfg_flag))

- .cloned()

- .collect(),

- (crate_id, crate_graph_crate_id)

- for (from, krate) in project.crates() {

- if let Some(&from) = crates.get(&from) {

- if let Some(&to) = crates.get(&dep.crate_id) {

- add_dep(crate_graph, from, dep.name.clone(), to)

- load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,

- let cfg_options = create_cfg_options(rustc_cfg);

- // Add test cfg for local crates

- if !override_cfg.global.is_empty() {

- cfg_options.apply_diff(override_cfg.global.clone());

- };

- if let Some(diff) = override_cfg.selective.get(&cargo[pkg].name) {

- // FIXME: this is sort of a hack to deal with #![cfg(not(test))] vanishing such as seen

- // in ed25519_dalek (#7243), and libcore (#9203) (although you only hit that one while

- // working on rust-lang/rust as that's the only time it appears outside sysroot).

- //

- // A more ideal solution might be to reanalyze crates based on where the cursor is and

- // figure out the set of cfgs that would have to apply to make it active.

-

- cfg_options.apply_diff(diff.clone());

- };

-fn detached_files_to_crate_graph(

- load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,

- detached_files: &[AbsPathBuf],

- let mut cfg_options = create_cfg_options(rustc_cfg);

- for detached_file in detached_files {

- let file_id = match load(detached_file) {

- Some(file_id) => file_id,

- None => {

- tracing::error!("Failed to load detached file {:?}", detached_file);

- continue;

- }

- };

- let display_name = detached_file

- .file_stem()

- .map(|file_stem| CrateDisplayName::from_canonical_name(file_stem.to_owned()));

- let detached_file_crate = crate_graph.add_crate_root(

- file_id,

- Edition::CURRENT,

- display_name.clone(),

- None,

- cfg_options.clone(),

- None,

- Env::default(),

- false,

- CrateOrigin::Local {

- repo: None,

- name: display_name.map(|n| n.canonical_name().to_owned()),

- },

- );

-

- public_deps.add_to_crate_graph(&mut crate_graph, detached_file_crate);

- }

- load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,

-

- if !override_cfg.global.is_empty() {

- cfg_options.apply_diff(override_cfg.global.clone());

- };

- if let Some(diff) = override_cfg.selective.get(&rustc_workspace[pkg].name) {

- // FIXME: this is sort of a hack to deal with #![cfg(not(test))] vanishing such as seen

- // in ed25519_dalek (#7243), and libcore (#9203) (although you only hit that one while

- // working on rust-lang/rust as that's the only time it appears outside sysroot).

- //

- // A more ideal solution might be to reanalyze crates based on where the cursor is and

- // figure out the set of cfgs that would have to apply to make it active.

-

- cfg_options.apply_diff(diff.clone());

- };

- 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('-', "_"));

- }

-

- let display_name = CrateDisplayName::from_canonical_name(cargo_name.to_owned());

- Some(display_name),

- cfg_options,

- potential_cfg_options,

- load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,

- &CfgOverrides::default(),

- c.cfg_options.apply_diff(diff.clone());

- let cfg_options = create_cfg_options(rustc_cfg);

- let env = Env::default();

- env,

-

-/// 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()

-}