Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'crates/project-model/src/workspace.rs')
| -rw-r--r-- | crates/project-model/src/workspace.rs | 354 |
1 files changed, 217 insertions, 137 deletions
diff --git a/crates/project-model/src/workspace.rs b/crates/project-model/src/workspace.rs index 62c13c7d9e..c6e0cf36af 100644 --- a/crates/project-model/src/workspace.rs +++ b/crates/project-model/src/workspace.rs @@ -6,11 +6,12 @@ use std::{collections::VecDeque, fmt, fs, iter, ops::Deref, sync, thread}; use anyhow::Context; use base_db::{ - CrateDisplayName, CrateGraph, CrateId, CrateName, CrateOrigin, Dependency, Env, - LangCrateOrigin, ProcMacroPaths, TargetLayoutLoadResult, + CrateBuilderId, CrateDisplayName, CrateGraphBuilder, CrateName, CrateOrigin, + CrateWorkspaceData, DependencyBuilder, Env, LangCrateOrigin, ProcMacroPaths, + TargetLayoutLoadResult, }; use cfg::{CfgAtom, CfgDiff, CfgOptions}; -use intern::{sym, Symbol}; +use intern::{Symbol, sym}; use paths::{AbsPath, AbsPathBuf}; use rustc_hash::{FxHashMap, FxHashSet}; use semver::Version; @@ -19,15 +20,15 @@ use tracing::instrument; use triomphe::Arc; use crate::{ + CargoConfig, CargoWorkspace, CfgOverrides, InvocationStrategy, ManifestPath, Package, + ProjectJson, ProjectManifest, RustSourceWorkspaceConfig, Sysroot, TargetData, TargetKind, + WorkspaceBuildScripts, build_dependencies::BuildScriptOutput, cargo_workspace::{CargoMetadataConfig, DepKind, PackageData, RustLibSource}, env::{cargo_config_env, inject_cargo_env, inject_cargo_package_env, inject_rustc_tool_env}, project_json::{Crate, CrateArrayIdx}, sysroot::RustLibSrcWorkspace, - toolchain_info::{rustc_cfg, target_data_layout, target_tuple, version, QueryConfig}, - CargoConfig, CargoWorkspace, CfgOverrides, InvocationStrategy, ManifestPath, Package, - ProjectJson, ProjectManifest, RustSourceWorkspaceConfig, Sysroot, TargetData, TargetKind, - WorkspaceBuildScripts, + toolchain_info::{QueryConfig, rustc_cfg, target_data_layout, target_tuple, version}, }; use tracing::{debug, error, info}; @@ -219,6 +220,7 @@ impl ProjectWorkspace { sysroot, sysroot_src, target, + no_deps, .. } = config; let mut sysroot = match (sysroot, sysroot_src) { @@ -300,12 +302,17 @@ impl ProjectWorkspace { extra_env: extra_env.clone(), }, &sysroot, + *no_deps, false, &|_| (), ) { Ok((meta, _error)) => { - let workspace = - CargoWorkspace::new(meta, cargo_toml.clone(), Env::default()); + let workspace = CargoWorkspace::new( + meta, + cargo_toml.clone(), + Env::default(), + false, + ); let build_scripts = WorkspaceBuildScripts::rustc_crates( &workspace, workspace_dir, @@ -320,8 +327,8 @@ impl ProjectWorkspace { "Failed to read Cargo metadata from rustc source at {rustc_dir}", ); Err(Some(format!( - "Failed to read Cargo metadata from rustc source at {rustc_dir}: {e}" - ))) + "Failed to read Cargo metadata from rustc source at {rustc_dir}: {e}" + ))) } } }) @@ -338,6 +345,7 @@ impl ProjectWorkspace { extra_env: extra_env.clone(), }, &sysroot, + *no_deps, false, &|_| (), ) @@ -378,7 +386,7 @@ impl ProjectWorkspace { "Failed to read Cargo metadata from Cargo.toml file {cargo_toml}, {toolchain:?}", ) })?; - let cargo = CargoWorkspace::new(meta, cargo_toml.clone(), cargo_config_extra_env); + let cargo = CargoWorkspace::new(meta, cargo_toml.clone(), cargo_config_extra_env, false); if let Some(loaded_sysroot) = loaded_sysroot { sysroot.set_workspace(loaded_sysroot); } @@ -506,6 +514,7 @@ impl ProjectWorkspace { extra_env: config.extra_env.clone(), }, &sysroot, + config.no_deps, false, &|_| (), ) @@ -514,7 +523,7 @@ impl ProjectWorkspace { let cargo_config_extra_env = cargo_config_env(detached_file, &config.extra_env, &sysroot); ( - CargoWorkspace::new(ws, detached_file.clone(), cargo_config_extra_env), + CargoWorkspace::new(ws, detached_file.clone(), cargo_config_extra_env, false), WorkspaceBuildScripts::default(), error.map(Arc::new), ) @@ -847,11 +856,15 @@ impl ProjectWorkspace { pub fn to_crate_graph( &self, load: FileLoader<'_>, - extra_env: &FxHashMap<String, String>, - ) -> (CrateGraph, ProcMacroPaths) { + extra_env: &FxHashMap<String, Option<String>>, + ) -> (CrateGraphBuilder, ProcMacroPaths) { let _p = tracing::info_span!("ProjectWorkspace::to_crate_graph").entered(); let Self { kind, sysroot, cfg_overrides, rustc_cfg, .. } = self; + let crate_ws_data = Arc::new(CrateWorkspaceData { + toolchain: self.toolchain.clone(), + data_layout: self.target_layout.clone(), + }); let (crate_graph, proc_macros) = match kind { ProjectWorkspaceKind::Json(project) => project_json_to_crate_graph( rustc_cfg.clone(), @@ -861,6 +874,8 @@ impl ProjectWorkspace { extra_env, cfg_overrides, self.set_test, + false, + crate_ws_data, ), ProjectWorkspaceKind::Cargo { cargo, rustc, build_scripts, error: _ } => { cargo_to_crate_graph( @@ -872,6 +887,7 @@ impl ProjectWorkspace { cfg_overrides, build_scripts, self.set_test, + crate_ws_data, ) } ProjectWorkspaceKind::DetachedFile { file, cargo: cargo_script, .. } => { @@ -885,6 +901,7 @@ impl ProjectWorkspace { cfg_overrides, build_scripts, self.set_test, + crate_ws_data, ) } else { detached_file_to_crate_graph( @@ -894,6 +911,7 @@ impl ProjectWorkspace { sysroot, cfg_overrides, self.set_test, + crate_ws_data, ) } } @@ -956,18 +974,27 @@ fn project_json_to_crate_graph( load: FileLoader<'_>, project: &ProjectJson, sysroot: &Sysroot, - extra_env: &FxHashMap<String, String>, + extra_env: &FxHashMap<String, Option<String>>, override_cfg: &CfgOverrides, set_test: bool, -) -> (CrateGraph, ProcMacroPaths) { - let mut res = (CrateGraph::default(), ProcMacroPaths::default()); + is_sysroot: bool, + crate_ws_data: Arc<CrateWorkspaceData>, +) -> (CrateGraphBuilder, ProcMacroPaths) { + let mut res = (CrateGraphBuilder::default(), ProcMacroPaths::default()); let (crate_graph, proc_macros) = &mut res; - let (public_deps, libproc_macro) = - sysroot_to_crate_graph(crate_graph, sysroot, rustc_cfg.clone(), load); + let (public_deps, libproc_macro) = sysroot_to_crate_graph( + crate_graph, + sysroot, + rustc_cfg.clone(), + load, + // FIXME: This looks incorrect but I don't think this matters. + crate_ws_data.clone(), + ); let mut cfg_cache: FxHashMap<&str, Vec<CfgAtom>> = FxHashMap::default(); + let project_root = Arc::new(project.project_root().to_path_buf()); - let idx_to_crate_id: FxHashMap<CrateArrayIdx, CrateId> = project + let idx_to_crate_id: FxHashMap<CrateArrayIdx, _> = project .crates() .filter_map(|(idx, krate)| Some((idx, krate, load(&krate.root_module)?))) .map( @@ -1007,11 +1034,11 @@ fn project_json_to_crate_graph( target_cfgs.iter().chain(cfg.iter()).cloned().collect(); if *is_workspace_member { - if set_test { + if set_test && !is_sysroot { // Add test cfg for local crates - cfg_options.insert_atom(sym::test.clone()); + cfg_options.insert_atom(sym::test); } - cfg_options.insert_atom(sym::rust_analyzer.clone()); + cfg_options.insert_atom(sym::rust_analyzer); } override_cfg.apply( @@ -1029,19 +1056,27 @@ fn project_json_to_crate_graph( *edition, display_name.clone(), version.clone(), - Arc::new(cfg_options), + cfg_options, None, env, if let Some(name) = display_name.clone() { - CrateOrigin::Local { - repo: repository.clone(), - name: Some(name.canonical_name().to_owned()), + if is_sysroot { + CrateOrigin::Lang(LangCrateOrigin::from(name.canonical_name().as_str())) + } else { + CrateOrigin::Local { + repo: repository.clone(), + name: Some(name.canonical_name().to_owned()), + } } } else { CrateOrigin::Local { repo: None, name: None } }, *is_proc_macro, - proc_macro_cwd.clone(), + match proc_macro_cwd { + Some(path) => Arc::new(path.clone()), + None => project_root.clone(), + }, + crate_ws_data.clone(), ); debug!( ?crate_graph_crate_id, @@ -1092,12 +1127,18 @@ fn cargo_to_crate_graph( override_cfg: &CfgOverrides, build_scripts: &WorkspaceBuildScripts, set_test: bool, -) -> (CrateGraph, ProcMacroPaths) { + crate_ws_data: Arc<CrateWorkspaceData>, +) -> (CrateGraphBuilder, ProcMacroPaths) { let _p = tracing::info_span!("cargo_to_crate_graph").entered(); - let mut res = (CrateGraph::default(), ProcMacroPaths::default()); + let mut res = (CrateGraphBuilder::default(), ProcMacroPaths::default()); let (crate_graph, proc_macros) = &mut res; - let (public_deps, libproc_macro) = - sysroot_to_crate_graph(crate_graph, sysroot, rustc_cfg.clone(), load); + let (public_deps, libproc_macro) = sysroot_to_crate_graph( + crate_graph, + sysroot, + rustc_cfg.clone(), + load, + crate_ws_data.clone(), + ); let cfg_options = CfgOptions::from_iter(rustc_cfg); @@ -1106,6 +1147,7 @@ fn cargo_to_crate_graph( let mut pkg_crates = FxHashMap::default(); // Does any crate signal to rust-analyzer that they need the rustc_private crates? let mut has_private = false; + let workspace_proc_macro_cwd = Arc::new(cargo.workspace_root().to_path_buf()); // Next, create crates for each package, target pair for pkg in cargo.packages() { @@ -1115,11 +1157,11 @@ fn cargo_to_crate_graph( let mut cfg_options = cfg_options.clone(); if cargo[pkg].is_local { - if set_test { + if set_test && !cargo.is_sysroot() { // Add test cfg for local crates - cfg_options.insert_atom(sym::test.clone()); + cfg_options.insert_atom(sym::test); } - cfg_options.insert_atom(sym::rust_analyzer.clone()); + cfg_options.insert_atom(sym::rust_analyzer); } override_cfg.apply(&mut cfg_options, &cargo[pkg].name); @@ -1128,7 +1170,10 @@ fn cargo_to_crate_graph( let mut lib_tgt = None; for &tgt in cargo[pkg].targets.iter() { - if !matches!(cargo[tgt].kind, TargetKind::Lib { .. }) && !cargo[pkg].is_member { + let pkg_data = &cargo[pkg]; + if !matches!(cargo[tgt].kind, TargetKind::Lib { .. }) + && (!pkg_data.is_member || cargo.is_sysroot()) + { // For non-workspace-members, Cargo does not resolve dev-dependencies, so we don't // add any targets except the library target, since those will not work correctly if // they use dev-dependencies. @@ -1141,7 +1186,6 @@ fn cargo_to_crate_graph( let Some(file_id) = load(root) else { continue }; let build_data = build_scripts.get_output(pkg); - let pkg_data = &cargo[pkg]; let crate_id = add_target_crate_root( crate_graph, proc_macros, @@ -1153,9 +1197,13 @@ fn cargo_to_crate_graph( name, kind, if pkg_data.is_local { - CrateOrigin::Local { - repo: pkg_data.repository.clone(), - name: Some(Symbol::intern(&pkg_data.name)), + if cargo.is_sysroot() { + CrateOrigin::Lang(LangCrateOrigin::from(&*pkg_data.name)) + } else { + CrateOrigin::Local { + repo: pkg_data.repository.clone(), + name: Some(Symbol::intern(&pkg_data.name)), + } } } else { CrateOrigin::Library { @@ -1163,6 +1211,12 @@ fn cargo_to_crate_graph( name: Symbol::intern(&pkg_data.name), } }, + crate_ws_data.clone(), + if pkg_data.is_member { + workspace_proc_macro_cwd.clone() + } else { + Arc::new(pkg_data.manifest.parent().to_path_buf()) + }, ); if let TargetKind::Lib { .. } = kind { lib_tgt = Some((crate_id, name.clone())); @@ -1267,6 +1321,8 @@ fn cargo_to_crate_graph( } else { rustc_build_scripts }, + // FIXME: This looks incorrect but I don't think this causes problems. + crate_ws_data, ); } } @@ -1280,19 +1336,26 @@ fn detached_file_to_crate_graph( sysroot: &Sysroot, override_cfg: &CfgOverrides, set_test: bool, -) -> (CrateGraph, ProcMacroPaths) { + crate_ws_data: Arc<CrateWorkspaceData>, +) -> (CrateGraphBuilder, ProcMacroPaths) { let _p = tracing::info_span!("detached_file_to_crate_graph").entered(); - let mut crate_graph = CrateGraph::default(); - let (public_deps, _libproc_macro) = - sysroot_to_crate_graph(&mut crate_graph, sysroot, rustc_cfg.clone(), load); + let mut crate_graph = CrateGraphBuilder::default(); + let (public_deps, _libproc_macro) = sysroot_to_crate_graph( + &mut crate_graph, + sysroot, + rustc_cfg.clone(), + load, + // FIXME: This looks incorrect but I don't think this causes problems. + crate_ws_data.clone(), + ); let mut cfg_options = CfgOptions::from_iter(rustc_cfg); if set_test { - cfg_options.insert_atom(sym::test.clone()); + cfg_options.insert_atom(sym::test); } - cfg_options.insert_atom(sym::rust_analyzer.clone()); + cfg_options.insert_atom(sym::rust_analyzer); override_cfg.apply(&mut cfg_options, ""); - let cfg_options = Arc::new(cfg_options); + let cfg_options = cfg_options; let file_id = match load(detached_file) { Some(file_id) => file_id, @@ -1315,31 +1378,35 @@ fn detached_file_to_crate_graph( name: display_name.map(|n| n.canonical_name().to_owned()), }, false, - None, + Arc::new(detached_file.parent().to_path_buf()), + crate_ws_data, ); public_deps.add_to_crate_graph(&mut crate_graph, detached_file_crate); (crate_graph, FxHashMap::default()) } +// FIXME: There shouldn't really be a need for duplicating all of this? fn handle_rustc_crates( - crate_graph: &mut CrateGraph, + crate_graph: &mut CrateGraphBuilder, proc_macros: &mut ProcMacroPaths, - pkg_to_lib_crate: &mut FxHashMap<Package, CrateId>, + pkg_to_lib_crate: &mut FxHashMap<Package, CrateBuilderId>, load: FileLoader<'_>, rustc_workspace: &CargoWorkspace, cargo: &CargoWorkspace, public_deps: &SysrootPublicDeps, - libproc_macro: Option<CrateId>, - pkg_crates: &FxHashMap<Package, Vec<(CrateId, TargetKind)>>, + libproc_macro: Option<CrateBuilderId>, + pkg_crates: &FxHashMap<Package, Vec<(CrateBuilderId, TargetKind)>>, cfg_options: &CfgOptions, override_cfg: &CfgOverrides, build_scripts: &WorkspaceBuildScripts, + crate_ws_data: Arc<CrateWorkspaceData>, ) { let mut rustc_pkg_crates = FxHashMap::default(); // The root package of the rustc-dev component is rustc_driver, so we match that let root_pkg = rustc_workspace.packages().find(|&package| rustc_workspace[package].name == "rustc_driver"); + let workspace_proc_macro_cwd = Arc::new(cargo.workspace_root().to_path_buf()); // The rustc workspace might be incomplete (such as if rustc-dev is not // installed for the current toolchain) and `rustc_source` is set to discover. if let Some(root_pkg) = root_pkg { @@ -1353,14 +1420,15 @@ fn handle_rustc_crates( if rustc_pkg_crates.contains_key(&pkg) { continue; } - for dep in &rustc_workspace[pkg].dependencies { + let pkg_data = &rustc_workspace[pkg]; + for dep in &pkg_data.dependencies { queue.push_back(dep.pkg); } let mut cfg_options = cfg_options.clone(); - override_cfg.apply(&mut cfg_options, &rustc_workspace[pkg].name); + override_cfg.apply(&mut cfg_options, &pkg_data.name); - for &tgt in rustc_workspace[pkg].targets.iter() { + for &tgt in pkg_data.targets.iter() { let kind @ TargetKind::Lib { is_proc_macro } = rustc_workspace[tgt].kind else { continue; }; @@ -1370,13 +1438,19 @@ fn handle_rustc_crates( crate_graph, proc_macros, rustc_workspace, - &rustc_workspace[pkg], + pkg_data, build_scripts.get_output(pkg).zip(Some(build_scripts.error().is_some())), cfg_options.clone(), file_id, &rustc_workspace[tgt].name, kind, - CrateOrigin::Rustc { name: Symbol::intern(&rustc_workspace[pkg].name) }, + CrateOrigin::Rustc { name: Symbol::intern(&pkg_data.name) }, + crate_ws_data.clone(), + if pkg_data.is_member { + workspace_proc_macro_cwd.clone() + } else { + Arc::new(pkg_data.manifest.parent().to_path_buf()) + }, ); pkg_to_lib_crate.insert(pkg, crate_id); // Add dependencies on core / std / alloc for this crate @@ -1417,7 +1491,7 @@ fn handle_rustc_crates( // This avoids the situation where `from` depends on e.g. `arrayvec`, but // `rust_analyzer` thinks that it should use the one from the `rustc_source` // instead of the one from `crates.io` - if !crate_graph[*from].dependencies.iter().any(|d| d.name == name) { + if !crate_graph[*from].basic.dependencies.iter().any(|d| d.name == name) { add_dep(crate_graph, *from, name.clone(), to); } } @@ -1427,7 +1501,7 @@ fn handle_rustc_crates( } fn add_target_crate_root( - crate_graph: &mut CrateGraph, + crate_graph: &mut CrateGraphBuilder, proc_macros: &mut ProcMacroPaths, cargo: &CargoWorkspace, pkg: &PackageData, @@ -1437,22 +1511,25 @@ fn add_target_crate_root( cargo_name: &str, kind: TargetKind, origin: CrateOrigin, -) -> CrateId { + crate_ws_data: Arc<CrateWorkspaceData>, + proc_macro_cwd: Arc<AbsPathBuf>, +) -> CrateBuilderId { let edition = pkg.edition; let potential_cfg_options = if pkg.features.is_empty() { None } else { let mut potential_cfg_options = cfg_options.clone(); - potential_cfg_options.extend(pkg.features.iter().map(|feat| CfgAtom::KeyValue { - key: sym::feature.clone(), - value: Symbol::intern(feat.0), - })); + potential_cfg_options.extend( + pkg.features + .iter() + .map(|feat| CfgAtom::KeyValue { key: sym::feature, value: Symbol::intern(feat.0) }), + ); Some(potential_cfg_options) }; let cfg_options = { let mut opts = cfg_options; for feature in pkg.active_features.iter() { - opts.insert_key_value(sym::feature.clone(), Symbol::intern(feature)); + opts.insert_key_value(sym::feature, Symbol::intern(feature)); } if let Some(cfgs) = build_data.map(|(it, _)| &it.cfgs) { opts.extend(cfgs.iter().cloned()); @@ -1473,16 +1550,13 @@ fn add_target_crate_root( edition, Some(CrateDisplayName::from_canonical_name(cargo_name)), Some(pkg.version.to_string()), - Arc::new(cfg_options), - potential_cfg_options.map(Arc::new), + cfg_options, + potential_cfg_options, env, origin, matches!(kind, TargetKind::Lib { is_proc_macro: true }), - Some(if pkg.is_member { - cargo.workspace_root().to_path_buf() - } else { - pkg.manifest.parent().to_path_buf() - }), + proc_macro_cwd, + crate_ws_data, ); if let TargetKind::Lib { is_proc_macro: true } = kind { let proc_macro = match build_data { @@ -1503,12 +1577,12 @@ fn add_target_crate_root( #[derive(Default, Debug)] struct SysrootPublicDeps { - deps: Vec<(CrateName, CrateId, bool)>, + deps: Vec<(CrateName, CrateBuilderId, bool)>, } impl SysrootPublicDeps { /// Makes `from` depend on the public sysroot crates. - fn add_to_crate_graph(&self, crate_graph: &mut CrateGraph, from: CrateId) { + fn add_to_crate_graph(&self, crate_graph: &mut CrateGraphBuilder, from: CrateBuilderId) { for (name, krate, prelude) in &self.deps { add_dep_with_prelude(crate_graph, from, name.clone(), *krate, *prelude, true); } @@ -1516,22 +1590,14 @@ impl SysrootPublicDeps { } fn extend_crate_graph_with_sysroot( - crate_graph: &mut CrateGraph, - mut sysroot_crate_graph: CrateGraph, + crate_graph: &mut CrateGraphBuilder, + mut sysroot_crate_graph: CrateGraphBuilder, mut sysroot_proc_macros: ProcMacroPaths, -) -> (SysrootPublicDeps, Option<CrateId>) { +) -> (SysrootPublicDeps, Option<CrateBuilderId>) { let mut pub_deps = vec![]; let mut libproc_macro = None; - let diff = CfgDiff::new(vec![], vec![CfgAtom::Flag(sym::test.clone())]); - for (cid, c) in sysroot_crate_graph.iter_mut() { - // uninject `test` flag so `core` keeps working. - Arc::make_mut(&mut c.cfg_options).apply_diff(diff.clone()); - // patch the origin - if c.origin.is_local() { - let lang_crate = LangCrateOrigin::from( - c.display_name.as_ref().map_or("", |it| it.canonical_name().as_str()), - ); - c.origin = CrateOrigin::Lang(lang_crate); + for cid in sysroot_crate_graph.iter() { + if let CrateOrigin::Lang(lang_crate) = sysroot_crate_graph[cid].basic.origin { match lang_crate { LangCrateOrigin::Test | LangCrateOrigin::Alloc @@ -1579,15 +1645,16 @@ fn extend_crate_graph_with_sysroot( } fn sysroot_to_crate_graph( - crate_graph: &mut CrateGraph, + crate_graph: &mut CrateGraphBuilder, sysroot: &Sysroot, rustc_cfg: Vec<CfgAtom>, load: FileLoader<'_>, -) -> (SysrootPublicDeps, Option<CrateId>) { + crate_ws_data: Arc<CrateWorkspaceData>, +) -> (SysrootPublicDeps, Option<CrateBuilderId>) { let _p = tracing::info_span!("sysroot_to_crate_graph").entered(); match sysroot.workspace() { RustLibSrcWorkspace::Workspace(cargo) => { - let (cg, pm) = cargo_to_crate_graph( + let (sysroot_cg, sysroot_pm) = cargo_to_crate_graph( load, None, cargo, @@ -1596,21 +1663,23 @@ fn sysroot_to_crate_graph( &CfgOverrides { global: CfgDiff::new( vec![ - CfgAtom::Flag(sym::debug_assertions.clone()), - CfgAtom::Flag(sym::miri.clone()), + CfgAtom::Flag(sym::debug_assertions), + CfgAtom::Flag(sym::miri), + CfgAtom::Flag(sym::bootstrap), ], - vec![], + vec![CfgAtom::Flag(sym::test)], ), ..Default::default() }, &WorkspaceBuildScripts::default(), false, + crate_ws_data, ); - extend_crate_graph_with_sysroot(crate_graph, cg, pm) + extend_crate_graph_with_sysroot(crate_graph, sysroot_cg, sysroot_pm) } RustLibSrcWorkspace::Json(project_json) => { - let (cg, pm) = project_json_to_crate_graph( + let (sysroot_cg, sysroot_pm) = project_json_to_crate_graph( rustc_cfg, load, project_json, @@ -1618,50 +1687,51 @@ fn sysroot_to_crate_graph( &FxHashMap::default(), &CfgOverrides { global: CfgDiff::new( - vec![ - CfgAtom::Flag(sym::debug_assertions.clone()), - CfgAtom::Flag(sym::miri.clone()), - ], + vec![CfgAtom::Flag(sym::debug_assertions), CfgAtom::Flag(sym::miri)], vec![], ), ..Default::default() }, false, + true, + crate_ws_data, ); - extend_crate_graph_with_sysroot(crate_graph, cg, pm) + extend_crate_graph_with_sysroot(crate_graph, sysroot_cg, sysroot_pm) } RustLibSrcWorkspace::Stitched(stitched) => { - let cfg_options = Arc::new({ + let cfg_options = { let mut cfg_options = CfgOptions::default(); cfg_options.extend(rustc_cfg); - cfg_options.insert_atom(sym::debug_assertions.clone()); - cfg_options.insert_atom(sym::miri.clone()); + cfg_options.insert_atom(sym::debug_assertions); + cfg_options.insert_atom(sym::miri); cfg_options - }); - let sysroot_crates: FxHashMap<crate::sysroot::stitched::RustLibSrcCrate, CrateId> = - stitched - .crates() - .filter_map(|krate| { - let file_id = load(&stitched[krate].root)?; - - let display_name = - CrateDisplayName::from_canonical_name(&stitched[krate].name); - let crate_id = crate_graph.add_crate_root( - file_id, - Edition::CURRENT_FIXME, - Some(display_name), - None, - cfg_options.clone(), - None, - Env::default(), - CrateOrigin::Lang(LangCrateOrigin::from(&*stitched[krate].name)), - false, - None, - ); - Some((krate, crate_id)) - }) - .collect(); + }; + let sysroot_crates: FxHashMap< + crate::sysroot::stitched::RustLibSrcCrate, + CrateBuilderId, + > = stitched + .crates() + .filter_map(|krate| { + let file_id = load(&stitched[krate].root)?; + + let display_name = CrateDisplayName::from_canonical_name(&stitched[krate].name); + let crate_id = crate_graph.add_crate_root( + file_id, + Edition::CURRENT_FIXME, + Some(display_name), + None, + cfg_options.clone(), + None, + Env::default(), + CrateOrigin::Lang(LangCrateOrigin::from(&*stitched[krate].name)), + false, + Arc::new(stitched[krate].root.parent().to_path_buf()), + crate_ws_data.clone(), + ); + Some((krate, crate_id)) + }) + .collect(); for from in stitched.crates() { for &to in stitched[from].deps.iter() { @@ -1691,22 +1761,32 @@ fn sysroot_to_crate_graph( } } -fn add_dep(graph: &mut CrateGraph, from: CrateId, name: CrateName, to: CrateId) { - add_dep_inner(graph, from, Dependency::new(name, to)) +fn add_dep( + graph: &mut CrateGraphBuilder, + from: CrateBuilderId, + name: CrateName, + to: CrateBuilderId, +) { + add_dep_inner(graph, from, DependencyBuilder::new(name, to)) } fn add_dep_with_prelude( - graph: &mut CrateGraph, - from: CrateId, + graph: &mut CrateGraphBuilder, + from: CrateBuilderId, name: CrateName, - to: CrateId, + to: CrateBuilderId, prelude: bool, sysroot: bool, ) { - add_dep_inner(graph, from, Dependency::with_prelude(name, to, prelude, sysroot)) + add_dep_inner(graph, from, DependencyBuilder::with_prelude(name, to, prelude, sysroot)) } -fn add_proc_macro_dep(crate_graph: &mut CrateGraph, from: CrateId, to: CrateId, prelude: bool) { +fn add_proc_macro_dep( + crate_graph: &mut CrateGraphBuilder, + from: CrateBuilderId, + to: CrateBuilderId, + prelude: bool, +) { add_dep_with_prelude( crate_graph, from, @@ -1717,14 +1797,14 @@ fn add_proc_macro_dep(crate_graph: &mut CrateGraph, from: CrateId, to: CrateId, ); } -fn add_dep_inner(graph: &mut CrateGraph, from: CrateId, dep: Dependency) { +fn add_dep_inner(graph: &mut CrateGraphBuilder, from: CrateBuilderId, dep: DependencyBuilder) { if let Err(err) = graph.add_dep(from, dep) { tracing::warn!("{}", err) } } fn sysroot_metadata_config( - extra_env: &FxHashMap<String, String>, + extra_env: &FxHashMap<String, Option<String>>, targets: &[String], ) -> CargoMetadataConfig { CargoMetadataConfig { |