crates/project_model/src/workspace.rs

   1 //! Handles lowering of build-system specific workspace information (`cargo
   2 //! metadata` or `rust-project.json`) into representation stored in the salsa
   3 //! database -- `CrateGraph`.
   4
   5 use std::{collections::VecDeque, convert::TryFrom, fmt, fs, process::Command};
   6
   7 use anyhow::{format_err, Context, Result};
   8 use base_db::{
   9     CrateDisplayName, CrateGraph, CrateId, CrateName, Dependency, Edition, Env, FileId, ProcMacro,
  10 };
  11 use cfg::{CfgDiff, CfgOptions};
  12 use paths::{AbsPath, AbsPathBuf};
  13 use rustc_hash::{FxHashMap, FxHashSet};
  14 use stdx::always;
  15
  16 use crate::{
  17     build_scripts::BuildScriptOutput,
  18     cargo_workspace::{DepKind, PackageData, RustcSource},
  19     cfg_flag::CfgFlag,
  20     rustc_cfg,
  21     sysroot::SysrootCrate,
  22     utf8_stdout, CargoConfig, CargoWorkspace, ManifestPath, ProjectJson, ProjectManifest, Sysroot,
  23     TargetKind, WorkspaceBuildScripts,
  24 };
  25
  26 /// A set of cfg-overrides per crate.
  27 ///
  28 /// `Wildcard(..)` is useful e.g. disabling `#[cfg(test)]` on all crates,
  29 /// without having to first obtain a list of all crates.
  30 #[derive(Debug, Clone, Eq, PartialEq)]
  31 pub enum CfgOverrides {
  32     /// A single global set of overrides matching all crates.
  33     Wildcard(CfgDiff),
  34     /// A set of overrides matching specific crates.
  35     Selective(FxHashMap<String, CfgDiff>),
  36 }
  37
  38 impl Default for CfgOverrides {
  39     fn default() -> Self {
  40         Self::Selective(FxHashMap::default())
  41     }
  42 }
  43
  44 impl CfgOverrides {
  45     pub fn len(&self) -> usize {
  46         match self {
  47             CfgOverrides::Wildcard(_) => 1,
  48             CfgOverrides::Selective(hash_map) => hash_map.len(),
  49         }
  50     }
  51 }
  52
  53 /// `PackageRoot` describes a package root folder.
  54 /// Which may be an external dependency, or a member of
  55 /// the current workspace.
  56 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
  57 pub struct PackageRoot {
  58     /// Is from the local filesystem and may be edited
  59     pub is_local: bool,
  60     pub include: Vec<AbsPathBuf>,
  61     pub exclude: Vec<AbsPathBuf>,
  62 }
  63
  64 #[derive(Clone, Eq, PartialEq)]
  65 pub enum ProjectWorkspace {
  66     /// Project workspace was discovered by running `cargo metadata` and `rustc --print sysroot`.
  67     Cargo {
  68         cargo: CargoWorkspace,
  69         build_scripts: WorkspaceBuildScripts,
  70         sysroot: Option<Sysroot>,
  71         rustc: Option<CargoWorkspace>,
  72         /// Holds cfg flags for the current target. We get those by running
  73         /// `rustc --print cfg`.
  74         ///
  75         /// FIXME: make this a per-crate map, as, eg, build.rs might have a
  76         /// different target.
  77         rustc_cfg: Vec<CfgFlag>,
  78         cfg_overrides: CfgOverrides,
  79     },
  80     /// Project workspace was manually specified using a `rust-project.json` file.
  81     Json { project: ProjectJson, sysroot: Option<Sysroot>, rustc_cfg: Vec<CfgFlag> },
  82
  83     // FIXME: The primary limitation of this approach is that the set of detached files needs to be fixed at the beginning.
  84     // That's not the end user experience we should strive for.
  85     // Ideally, you should be able to just open a random detached file in existing cargo projects, and get the basic features working.
  86     // That needs some changes on the salsa-level though.
  87     // In particular, we should split the unified CrateGraph (which currently has maximal durability) into proper crate graph, and a set of ad hoc roots (with minimal durability).
  88     // Then, we need to hide the graph behind the queries such that most queries look only at the proper crate graph, and fall back to ad hoc roots only if there's no results.
  89     // After this, we should be able to tweak the logic in reload.rs to add newly opened files, which don't belong to any existing crates, to the set of the detached files.
  90     // //
  91     /// Project with a set of disjoint files, not belonging to any particular workspace.
  92     /// Backed by basic sysroot crates for basic completion and highlighting.
  93     DetachedFiles { files: Vec<AbsPathBuf>, sysroot: Sysroot, rustc_cfg: Vec<CfgFlag> },
  94 }
  95
  96 impl fmt::Debug for ProjectWorkspace {
  97     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  98         // Make sure this isn't too verbose.
  99         match self {
 100             ProjectWorkspace::Cargo {
 101                 cargo,
 102                 build_scripts: _,
 103                 sysroot,
 104                 rustc,
 105                 rustc_cfg,
 106                 cfg_overrides,
 107             } => f
 108                 .debug_struct("Cargo")
 109                 .field("root", &cargo.workspace_root().file_name())
 110                 .field("n_packages", &cargo.packages().len())
 111                 .field("sysroot", &sysroot.is_some())
 112                 .field(
 113                     "n_rustc_compiler_crates",
 114                     &rustc.as_ref().map_or(0, |rc| rc.packages().len()),
 115                 )
 116                 .field("n_rustc_cfg", &rustc_cfg.len())
 117                 .field("n_cfg_overrides", &cfg_overrides.len())
 118                 .finish(),
 119             ProjectWorkspace::Json { project, sysroot, rustc_cfg } => {
 120                 let mut debug_struct = f.debug_struct("Json");
 121                 debug_struct.field("n_crates", &project.n_crates());
 122                 if let Some(sysroot) = sysroot {
 123                     debug_struct.field("n_sysroot_crates", &sysroot.crates().len());
 124                 }
 125                 debug_struct.field("n_rustc_cfg", &rustc_cfg.len());
 126                 debug_struct.finish()
 127             }
 128             ProjectWorkspace::DetachedFiles { files, sysroot, rustc_cfg } => f
 129                 .debug_struct("DetachedFiles")
 130                 .field("n_files", &files.len())
 131                 .field("n_sysroot_crates", &sysroot.crates().len())
 132                 .field("n_rustc_cfg", &rustc_cfg.len())
 133                 .finish(),
 134         }
 135     }
 136 }
 137
 138 impl ProjectWorkspace {
 139     pub fn load(
 140         manifest: ProjectManifest,
 141         config: &CargoConfig,
 142         progress: &dyn Fn(String),
 143     ) -> Result<ProjectWorkspace> {
 144         let res = match manifest {
 145             ProjectManifest::ProjectJson(project_json) => {
 146                 let file = fs::read_to_string(&project_json).with_context(|| {
 147                     format!("Failed to read json file {}", project_json.display())
 148                 })?;
 149                 let data = serde_json::from_str(&file).with_context(|| {
 150                     format!("Failed to deserialize json file {}", project_json.display())
 151                 })?;
 152                 let project_location = project_json.parent().to_path_buf();
 153                 let project_json = ProjectJson::new(&project_location, data);
 154                 ProjectWorkspace::load_inline(project_json, config.target.as_deref())?
 155             }
 156             ProjectManifest::CargoToml(cargo_toml) => {
 157                 let cargo_version = utf8_stdout({
 158                     let mut cmd = Command::new(toolchain::cargo());
 159                     cmd.arg("--version");
 160                     cmd
 161                 })?;
 162
 163                 let meta = CargoWorkspace::fetch_metadata(&cargo_toml, config, progress)
 164                     .with_context(|| {
 165                         format!(
 166                             "Failed to read Cargo metadata from Cargo.toml file {}, {}",
 167                             cargo_toml.display(),
 168                             cargo_version
 169                         )
 170                     })?;
 171                 let cargo = CargoWorkspace::new(meta);
 172
 173                 let sysroot = if config.no_sysroot {
 174                     None
 175                 } else {
 176                     Some(Sysroot::discover(cargo_toml.parent()).with_context(|| {
 177                         format!(
 178                             "Failed to find sysroot for Cargo.toml file {}. Is rust-src installed?",
 179                             cargo_toml.display()
 180                         )
 181                     })?)
 182                 };
 183
 184                 let rustc_dir = match &config.rustc_source {
 185                     Some(RustcSource::Path(path)) => ManifestPath::try_from(path.clone()).ok(),
 186                     Some(RustcSource::Discover) => Sysroot::discover_rustc(&cargo_toml),
 187                     None => None,
 188                 };
 189
 190                 let rustc = match rustc_dir {
 191                     Some(rustc_dir) => Some({
 192                         let meta = CargoWorkspace::fetch_metadata(&rustc_dir, config, progress)
 193                             .with_context(|| {
 194                                 "Failed to read Cargo metadata for Rust sources".to_string()
 195                             })?;
 196                         CargoWorkspace::new(meta)
 197                     }),
 198                     None => None,
 199                 };
 200
 201                 let rustc_cfg = rustc_cfg::get(Some(&cargo_toml), config.target.as_deref());
 202
 203                 let cfg_overrides = config.cfg_overrides();
 204                 ProjectWorkspace::Cargo {
 205                     cargo,
 206                     build_scripts: WorkspaceBuildScripts::default(),
 207                     sysroot,
 208                     rustc,
 209                     rustc_cfg,
 210                     cfg_overrides,
 211                 }
 212             }
 213         };
 214
 215         Ok(res)
 216     }
 217
 218     pub fn load_inline(
 219         project_json: ProjectJson,
 220         target: Option<&str>,
 221     ) -> Result<ProjectWorkspace> {
 222         let sysroot = match &project_json.sysroot_src {
 223             Some(path) => Some(Sysroot::load(path.clone())?),
 224             None => None,
 225         };
 226         let rustc_cfg = rustc_cfg::get(None, target);
 227         Ok(ProjectWorkspace::Json { project: project_json, sysroot, rustc_cfg })
 228     }
 229
 230     pub fn load_detached_files(detached_files: Vec<AbsPathBuf>) -> Result<ProjectWorkspace> {
 231         let sysroot = Sysroot::discover(
 232             detached_files
 233                 .first()
 234                 .and_then(|it| it.parent())
 235                 .ok_or_else(|| format_err!("No detached files to load"))?,
 236         )?;
 237         let rustc_cfg = rustc_cfg::get(None, None);
 238         Ok(ProjectWorkspace::DetachedFiles { files: detached_files, sysroot, rustc_cfg })
 239     }
 240
 241     pub fn run_build_scripts(
 242         &self,
 243         config: &CargoConfig,
 244         progress: &dyn Fn(String),
 245     ) -> Result<WorkspaceBuildScripts> {
 246         match self {
 247             ProjectWorkspace::Cargo { cargo, .. } => {
 248                 WorkspaceBuildScripts::run(config, cargo, progress)
 249             }
 250             ProjectWorkspace::Json { .. } | ProjectWorkspace::DetachedFiles { .. } => {
 251                 Ok(WorkspaceBuildScripts::default())
 252             }
 253         }
 254     }
 255
 256     pub fn set_build_scripts(&mut self, bs: WorkspaceBuildScripts) {
 257         match self {
 258             ProjectWorkspace::Cargo { build_scripts, .. } => *build_scripts = bs,
 259             _ => {
 260                 always!(bs == WorkspaceBuildScripts::default());
 261             }
 262         }
 263     }
 264
 265     /// Returns the roots for the current `ProjectWorkspace`
 266     /// The return type contains the path and whether or not
 267     /// the root is a member of the current workspace
 268     pub fn to_roots(&self) -> Vec<PackageRoot> {
 269         match self {
 270             ProjectWorkspace::Json { project, sysroot, rustc_cfg: _ } => project
 271                 .crates()
 272                 .map(|(_, krate)| PackageRoot {
 273                     is_local: krate.is_workspace_member,
 274                     include: krate.include.clone(),
 275                     exclude: krate.exclude.clone(),
 276                 })
 277                 .collect::<FxHashSet<_>>()
 278                 .into_iter()
 279                 .chain(sysroot.as_ref().into_iter().flat_map(|sysroot| {
 280                     sysroot.crates().map(move |krate| PackageRoot {
 281                         is_local: false,
 282                         include: vec![sysroot[krate].root.parent().to_path_buf()],
 283                         exclude: Vec::new(),
 284                     })
 285                 }))
 286                 .collect::<Vec<_>>(),
 287             ProjectWorkspace::Cargo {
 288                 cargo,
 289                 sysroot,
 290                 rustc,
 291                 rustc_cfg: _,
 292                 cfg_overrides: _,
 293                 build_scripts,
 294             } => {
 295                 cargo
 296                     .packages()
 297                     .map(|pkg| {
 298                         let is_local = cargo[pkg].is_local;
 299                         let pkg_root = cargo[pkg].manifest.parent().to_path_buf();
 300
 301                         let mut include = vec![pkg_root.clone()];
 302                         include.extend(
 303                             build_scripts.outputs.get(pkg).and_then(|it| it.out_dir.clone()),
 304                         );
 305
 306                         // In case target's path is manually set in Cargo.toml to be
 307                         // outside the package root, add its parent as an extra include.
 308                         // An example of this situation would look like this:
 309                         //
 310                         // ```toml
 311                         // [lib]
 312                         // path = "../../src/lib.rs"
 313                         // ```
 314                         let extra_targets = cargo[pkg]
 315                             .targets
 316                             .iter()
 317                             .filter(|&&tgt| cargo[tgt].kind == TargetKind::Lib)
 318                             .filter_map(|&tgt| cargo[tgt].root.parent())
 319                             .map(|tgt| tgt.normalize().to_path_buf())
 320                             .filter(|path| !path.starts_with(&pkg_root));
 321                         include.extend(extra_targets);
 322
 323                         let mut exclude = vec![pkg_root.join(".git")];
 324                         if is_local {
 325                             exclude.push(pkg_root.join("target"));
 326                         } else {
 327                             exclude.push(pkg_root.join("tests"));
 328                             exclude.push(pkg_root.join("examples"));
 329                             exclude.push(pkg_root.join("benches"));
 330                         }
 331                         PackageRoot { is_local, include, exclude }
 332                     })
 333                     .chain(sysroot.iter().map(|sysroot| PackageRoot {
 334                         is_local: false,
 335                         include: vec![sysroot.root().to_path_buf()],
 336                         exclude: Vec::new(),
 337                     }))
 338                     .chain(rustc.iter().flat_map(|rustc| {
 339                         rustc.packages().map(move |krate| PackageRoot {
 340                             is_local: false,
 341                             include: vec![rustc[krate].manifest.parent().to_path_buf()],
 342                             exclude: Vec::new(),
 343                         })
 344                     }))
 345                     .collect()
 346             }
 347             ProjectWorkspace::DetachedFiles { files, sysroot, .. } => files
 348                 .iter()
 349                 .map(|detached_file| PackageRoot {
 350                     is_local: true,
 351                     include: vec![detached_file.clone()],
 352                     exclude: Vec::new(),
 353                 })
 354                 .chain(sysroot.crates().map(|krate| PackageRoot {
 355                     is_local: false,
 356                     include: vec![sysroot[krate].root.parent().to_path_buf()],
 357                     exclude: Vec::new(),
 358                 }))
 359                 .collect(),
 360         }
 361     }
 362
 363     pub fn n_packages(&self) -> usize {
 364         match self {
 365             ProjectWorkspace::Json { project, .. } => project.n_crates(),
 366             ProjectWorkspace::Cargo { cargo, sysroot, rustc, .. } => {
 367                 let rustc_package_len = rustc.as_ref().map_or(0, |it| it.packages().len());
 368                 let sysroot_package_len = sysroot.as_ref().map_or(0, |it| it.crates().len());
 369                 cargo.packages().len() + sysroot_package_len + rustc_package_len
 370             }
 371             ProjectWorkspace::DetachedFiles { sysroot, files, .. } => {
 372                 sysroot.crates().len() + files.len()
 373             }
 374         }
 375     }
 376
 377     pub fn to_crate_graph(
 378         &self,
 379         load_proc_macro: &mut dyn FnMut(&AbsPath) -> Vec<ProcMacro>,
 380         load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
 381     ) -> CrateGraph {
 382         let _p = profile::span("ProjectWorkspace::to_crate_graph");
 383
 384         let mut crate_graph = match self {
 385             ProjectWorkspace::Json { project, sysroot, rustc_cfg } => project_json_to_crate_graph(
 386                 rustc_cfg.clone(),
 387                 load_proc_macro,
 388                 load,
 389                 project,
 390                 sysroot,
 391             ),
 392             ProjectWorkspace::Cargo {
 393                 cargo,
 394                 sysroot,
 395                 rustc,
 396                 rustc_cfg,
 397                 cfg_overrides,
 398                 build_scripts,
 399             } => cargo_to_crate_graph(
 400                 rustc_cfg.clone(),
 401                 cfg_overrides,
 402                 load_proc_macro,
 403                 load,
 404                 cargo,
 405                 build_scripts,
 406                 sysroot.as_ref(),
 407                 rustc,
 408             ),
 409             ProjectWorkspace::DetachedFiles { files, sysroot, rustc_cfg } => {
 410                 detached_files_to_crate_graph(rustc_cfg.clone(), load, files, sysroot)
 411             }
 412         };
 413         if crate_graph.patch_cfg_if() {
 414             tracing::debug!("Patched std to depend on cfg-if")
 415         } else {
 416             tracing::debug!("Did not patch std to depend on cfg-if")
 417         }
 418         crate_graph
 419     }
 420 }
 421
 422 fn project_json_to_crate_graph(
 423     rustc_cfg: Vec<CfgFlag>,
 424     load_proc_macro: &mut dyn FnMut(&AbsPath) -> Vec<ProcMacro>,
 425     load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
 426     project: &ProjectJson,
 427     sysroot: &Option<Sysroot>,
 428 ) -> CrateGraph {
 429     let mut crate_graph = CrateGraph::default();
 430     let sysroot_deps = sysroot
 431         .as_ref()
 432         .map(|sysroot| sysroot_to_crate_graph(&mut crate_graph, sysroot, rustc_cfg.clone(), load));
 433
 434     let mut cfg_cache: FxHashMap<&str, Vec<CfgFlag>> = FxHashMap::default();
 435     let crates: FxHashMap<CrateId, CrateId> = project
 436         .crates()
 437         .filter_map(|(crate_id, krate)| {
 438             let file_path = &krate.root_module;
 439             let file_id = load(file_path)?;
 440             Some((crate_id, krate, file_id))
 441         })
 442         .map(|(crate_id, krate, file_id)| {
 443             let env = krate.env.clone().into_iter().collect();
 444             let proc_macro = krate.proc_macro_dylib_path.clone().map(|it| load_proc_macro(&it));
 445
 446             let target_cfgs = match krate.target.as_deref() {
 447                 Some(target) => {
 448                     cfg_cache.entry(target).or_insert_with(|| rustc_cfg::get(None, Some(target)))
 449                 }
 450                 None => &rustc_cfg,
 451             };
 452
 453             let mut cfg_options = CfgOptions::default();
 454             cfg_options.extend(target_cfgs.iter().chain(krate.cfg.iter()).cloned());
 455             (
 456                 crate_id,
 457                 crate_graph.add_crate_root(
 458                     file_id,
 459                     krate.edition,
 460                     krate.display_name.clone(),
 461                     cfg_options.clone(),
 462                     cfg_options,
 463                     env,
 464                     proc_macro.unwrap_or_default(),
 465                 ),
 466             )
 467         })
 468         .collect();
 469
 470     for (from, krate) in project.crates() {
 471         if let Some(&from) = crates.get(&from) {
 472             if let Some((public_deps, libproc_macro)) = &sysroot_deps {
 473                 for (name, to) in public_deps.iter() {
 474                     add_dep(&mut crate_graph, from, name.clone(), *to)
 475                 }
 476                 if krate.is_proc_macro {
 477                     if let Some(proc_macro) = libproc_macro {
 478                         add_dep(
 479                             &mut crate_graph,
 480                             from,
 481                             CrateName::new("proc_macro").unwrap(),
 482                             *proc_macro,
 483                         );
 484                     }
 485                 }
 486             }
 487
 488             for dep in &krate.deps {
 489                 if let Some(&to) = crates.get(&dep.crate_id) {
 490                     add_dep(&mut crate_graph, from, dep.name.clone(), to)
 491                 }
 492             }
 493         }
 494     }
 495     crate_graph
 496 }
 497
 498 fn cargo_to_crate_graph(
 499     rustc_cfg: Vec<CfgFlag>,
 500     override_cfg: &CfgOverrides,
 501     load_proc_macro: &mut dyn FnMut(&AbsPath) -> Vec<ProcMacro>,
 502     load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
 503     cargo: &CargoWorkspace,
 504     build_scripts: &WorkspaceBuildScripts,
 505     sysroot: Option<&Sysroot>,
 506     rustc: &Option<CargoWorkspace>,
 507 ) -> CrateGraph {
 508     let _p = profile::span("cargo_to_crate_graph");
 509     let mut crate_graph = CrateGraph::default();
 510     let (public_deps, libproc_macro) = match sysroot {
 511         Some(sysroot) => sysroot_to_crate_graph(&mut crate_graph, sysroot, rustc_cfg.clone(), load),
 512         None => (Vec::new(), None),
 513     };
 514
 515     let mut cfg_options = CfgOptions::default();
 516     cfg_options.extend(rustc_cfg);
 517
 518     let mut pkg_to_lib_crate = FxHashMap::default();
 519
 520     // Add test cfg for non-sysroot crates
 521     cfg_options.insert_atom("test".into());
 522     cfg_options.insert_atom("debug_assertions".into());
 523
 524     let mut pkg_crates = FxHashMap::default();
 525     // Does any crate signal to rust-analyzer that they need the rustc_private crates?
 526     let mut has_private = false;
 527     // Next, create crates for each package, target pair
 528     for pkg in cargo.packages() {
 529         let mut cfg_options = &cfg_options;
 530         let mut replaced_cfg_options;
 531
 532         let overrides = match override_cfg {
 533             CfgOverrides::Wildcard(cfg_diff) => Some(cfg_diff),
 534             CfgOverrides::Selective(cfg_overrides) => cfg_overrides.get(&cargo[pkg].name),
 535         };
 536
 537         if let Some(overrides) = overrides {
 538             // FIXME: this is sort of a hack to deal with #![cfg(not(test))] vanishing such as seen
 539             // in ed25519_dalek (#7243), and libcore (#9203) (although you only hit that one while
 540             // working on rust-lang/rust as that's the only time it appears outside sysroot).
 541             //
 542             // A more ideal solution might be to reanalyze crates based on where the cursor is and
 543             // figure out the set of cfgs that would have to apply to make it active.
 544
 545             replaced_cfg_options = cfg_options.clone();
 546             replaced_cfg_options.apply_diff(overrides.clone());
 547             cfg_options = &replaced_cfg_options;
 548         };
 549
 550         has_private |= cargo[pkg].metadata.rustc_private;
 551         let mut lib_tgt = None;
 552         for &tgt in cargo[pkg].targets.iter() {
 553             if let Some(file_id) = load(&cargo[tgt].root) {
 554                 let crate_id = add_target_crate_root(
 555                     &mut crate_graph,
 556                     &cargo[pkg],
 557                     build_scripts.outputs.get(pkg),
 558                     cfg_options,
 559                     load_proc_macro,
 560                     file_id,
 561                     &cargo[tgt].name,
 562                 );
 563                 if cargo[tgt].kind == TargetKind::Lib {
 564                     lib_tgt = Some((crate_id, cargo[tgt].name.clone()));
 565                     pkg_to_lib_crate.insert(pkg, crate_id);
 566                 }
 567                 if let Some(proc_macro) = libproc_macro {
 568                     add_dep(
 569                         &mut crate_graph,
 570                         crate_id,
 571                         CrateName::new("proc_macro").unwrap(),
 572                         proc_macro,
 573                     );
 574                 }
 575
 576                 pkg_crates.entry(pkg).or_insert_with(Vec::new).push((crate_id, cargo[tgt].kind));
 577             }
 578         }
 579
 580         // Set deps to the core, std and to the lib target of the current package
 581         for (from, kind) in pkg_crates.get(&pkg).into_iter().flatten() {
 582             if let Some((to, name)) = lib_tgt.clone() {
 583                 if to != *from && *kind != TargetKind::BuildScript {
 584                     // (build script can not depend on its library target)
 585
 586                     // For root projects with dashes in their name,
 587                     // cargo metadata does not do any normalization,
 588                     // so we do it ourselves currently
 589                     let name = CrateName::normalize_dashes(&name);
 590                     add_dep(&mut crate_graph, *from, name, to);
 591                 }
 592             }
 593             for (name, krate) in public_deps.iter() {
 594                 add_dep(&mut crate_graph, *from, name.clone(), *krate);
 595             }
 596         }
 597     }
 598
 599     // Now add a dep edge from all targets of upstream to the lib
 600     // target of downstream.
 601     for pkg in cargo.packages() {
 602         for dep in cargo[pkg].dependencies.iter() {
 603             let name = CrateName::new(&dep.name).unwrap();
 604             if let Some(&to) = pkg_to_lib_crate.get(&dep.pkg) {
 605                 for (from, kind) in pkg_crates.get(&pkg).into_iter().flatten() {
 606                     if dep.kind == DepKind::Build && *kind != TargetKind::BuildScript {
 607                         // Only build scripts may depend on build dependencies.
 608                         continue;
 609                     }
 610                     if dep.kind != DepKind::Build && *kind == TargetKind::BuildScript {
 611                         // Build scripts may only depend on build dependencies.
 612                         continue;
 613                     }
 614
 615                     add_dep(&mut crate_graph, *from, name.clone(), to)
 616                 }
 617             }
 618         }
 619     }
 620
 621     if has_private {
 622         // If the user provided a path to rustc sources, we add all the rustc_private crates
 623         // and create dependencies on them for the crates which opt-in to that
 624         if let Some(rustc_workspace) = rustc {
 625             handle_rustc_crates(
 626                 rustc_workspace,
 627                 load,
 628                 &mut crate_graph,
 629                 &cfg_options,
 630                 load_proc_macro,
 631                 &mut pkg_to_lib_crate,
 632                 &public_deps,
 633                 cargo,
 634                 &pkg_crates,
 635             );
 636         }
 637     }
 638     crate_graph
 639 }
 640
 641 fn detached_files_to_crate_graph(
 642     rustc_cfg: Vec<CfgFlag>,
 643     load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
 644     detached_files: &[AbsPathBuf],
 645     sysroot: &Sysroot,
 646 ) -> CrateGraph {
 647     let _p = profile::span("detached_files_to_crate_graph");
 648     let mut crate_graph = CrateGraph::default();
 649     let (public_deps, _libproc_macro) =
 650         sysroot_to_crate_graph(&mut crate_graph, sysroot, rustc_cfg.clone(), load);
 651
 652     let mut cfg_options = CfgOptions::default();
 653     cfg_options.extend(rustc_cfg);
 654
 655     for detached_file in detached_files {
 656         let file_id = match load(detached_file) {
 657             Some(file_id) => file_id,
 658             None => {
 659                 tracing::error!("Failed to load detached file {:?}", detached_file);
 660                 continue;
 661             }
 662         };
 663         let display_name = detached_file
 664             .file_stem()
 665             .and_then(|os_str| os_str.to_str())
 666             .map(|file_stem| CrateDisplayName::from_canonical_name(file_stem.to_string()));
 667         let detached_file_crate = crate_graph.add_crate_root(
 668             file_id,
 669             Edition::CURRENT,
 670             display_name,
 671             cfg_options.clone(),
 672             cfg_options.clone(),
 673             Env::default(),
 674             Vec::new(),
 675         );
 676
 677         for (name, krate) in public_deps.iter() {
 678             add_dep(&mut crate_graph, detached_file_crate, name.clone(), *krate);
 679         }
 680     }
 681     crate_graph
 682 }
 683
 684 fn handle_rustc_crates(
 685     rustc_workspace: &CargoWorkspace,
 686     load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
 687     crate_graph: &mut CrateGraph,
 688     cfg_options: &CfgOptions,
 689     load_proc_macro: &mut dyn FnMut(&AbsPath) -> Vec<ProcMacro>,
 690     pkg_to_lib_crate: &mut FxHashMap<la_arena::Idx<crate::PackageData>, CrateId>,
 691     public_deps: &[(CrateName, CrateId)],
 692     cargo: &CargoWorkspace,
 693     pkg_crates: &FxHashMap<la_arena::Idx<crate::PackageData>, Vec<(CrateId, TargetKind)>>,
 694 ) {
 695     let mut rustc_pkg_crates = FxHashMap::default();
 696     // The root package of the rustc-dev component is rustc_driver, so we match that
 697     let root_pkg =
 698         rustc_workspace.packages().find(|package| rustc_workspace[*package].name == "rustc_driver");
 699     // The rustc workspace might be incomplete (such as if rustc-dev is not
 700     // installed for the current toolchain) and `rustcSource` is set to discover.
 701     if let Some(root_pkg) = root_pkg {
 702         // Iterate through every crate in the dependency subtree of rustc_driver using BFS
 703         let mut queue = VecDeque::new();
 704         queue.push_back(root_pkg);
 705         while let Some(pkg) = queue.pop_front() {
 706             // Don't duplicate packages if they are dependended on a diamond pattern
 707             // N.B. if this line is ommitted, we try to analyse over 4_800_000 crates
 708             // which is not ideal
 709             if rustc_pkg_crates.contains_key(&pkg) {
 710                 continue;
 711             }
 712             for dep in &rustc_workspace[pkg].dependencies {
 713                 queue.push_back(dep.pkg);
 714             }
 715             for &tgt in rustc_workspace[pkg].targets.iter() {
 716                 if rustc_workspace[tgt].kind != TargetKind::Lib {
 717                     continue;
 718                 }
 719                 if let Some(file_id) = load(&rustc_workspace[tgt].root) {
 720                     let crate_id = add_target_crate_root(
 721                         crate_graph,
 722                         &rustc_workspace[pkg],
 723                         None,
 724                         cfg_options,
 725                         load_proc_macro,
 726                         file_id,
 727                         &rustc_workspace[tgt].name,
 728                     );
 729                     pkg_to_lib_crate.insert(pkg, crate_id);
 730                     // Add dependencies on core / std / alloc for this crate
 731                     for (name, krate) in public_deps.iter() {
 732                         add_dep(crate_graph, crate_id, name.clone(), *krate);
 733                     }
 734                     rustc_pkg_crates.entry(pkg).or_insert_with(Vec::new).push(crate_id);
 735                 }
 736             }
 737         }
 738     }
 739     // Now add a dep edge from all targets of upstream to the lib
 740     // target of downstream.
 741     for pkg in rustc_pkg_crates.keys().copied() {
 742         for dep in rustc_workspace[pkg].dependencies.iter() {
 743             let name = CrateName::new(&dep.name).unwrap();
 744             if let Some(&to) = pkg_to_lib_crate.get(&dep.pkg) {
 745                 for &from in rustc_pkg_crates.get(&pkg).into_iter().flatten() {
 746                     add_dep(crate_graph, from, name.clone(), to);
 747                 }
 748             }
 749         }
 750     }
 751     // Add a dependency on the rustc_private crates for all targets of each package
 752     // which opts in
 753     for dep in rustc_workspace.packages() {
 754         let name = CrateName::normalize_dashes(&rustc_workspace[dep].name);
 755
 756         if let Some(&to) = pkg_to_lib_crate.get(&dep) {
 757             for pkg in cargo.packages() {
 758                 let package = &cargo[pkg];
 759                 if !package.metadata.rustc_private {
 760                     continue;
 761                 }
 762                 for (from, _) in pkg_crates.get(&pkg).into_iter().flatten() {
 763                     // Avoid creating duplicate dependencies
 764                     // This avoids the situation where `from` depends on e.g. `arrayvec`, but
 765                     // `rust_analyzer` thinks that it should use the one from the `rustcSource`
 766                     // instead of the one from `crates.io`
 767                     if !crate_graph[*from].dependencies.iter().any(|d| d.name == name) {
 768                         add_dep(crate_graph, *from, name.clone(), to);
 769                     }
 770                 }
 771             }
 772         }
 773     }
 774 }
 775
 776 fn add_target_crate_root(
 777     crate_graph: &mut CrateGraph,
 778     pkg: &PackageData,
 779     build_data: Option<&BuildScriptOutput>,
 780     cfg_options: &CfgOptions,
 781     load_proc_macro: &mut dyn FnMut(&AbsPath) -> Vec<ProcMacro>,
 782     file_id: FileId,
 783     cargo_name: &str,
 784 ) -> CrateId {
 785     let edition = pkg.edition;
 786     let cfg_options = {
 787         let mut opts = cfg_options.clone();
 788         for feature in pkg.active_features.iter() {
 789             opts.insert_key_value("feature".into(), feature.into());
 790         }
 791         if let Some(cfgs) = build_data.as_ref().map(|it| &it.cfgs) {
 792             opts.extend(cfgs.iter().cloned());
 793         }
 794         opts
 795     };
 796
 797     let mut env = Env::default();
 798     inject_cargo_env(pkg, &mut env);
 799
 800     if let Some(envs) = build_data.map(|it| &it.envs) {
 801         for (k, v) in envs {
 802             env.set(k, v.clone());
 803         }
 804     }
 805
 806     let proc_macro = build_data
 807         .as_ref()
 808         .and_then(|it| it.proc_macro_dylib_path.as_ref())
 809         .map(|it| load_proc_macro(it))
 810         .unwrap_or_default();
 811
 812     let display_name = CrateDisplayName::from_canonical_name(cargo_name.to_string());
 813     let mut potential_cfg_options = cfg_options.clone();
 814     potential_cfg_options.extend(
 815         pkg.features
 816             .iter()
 817             .map(|feat| CfgFlag::KeyValue { key: "feature".into(), value: feat.0.into() }),
 818     );
 819
 820     crate_graph.add_crate_root(
 821         file_id,
 822         edition,
 823         Some(display_name),
 824         cfg_options,
 825         potential_cfg_options,
 826         env,
 827         proc_macro,
 828     )
 829 }
 830
 831 fn sysroot_to_crate_graph(
 832     crate_graph: &mut CrateGraph,
 833     sysroot: &Sysroot,
 834     rustc_cfg: Vec<CfgFlag>,
 835     load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
 836 ) -> (Vec<(CrateName, CrateId)>, Option<CrateId>) {
 837     let _p = profile::span("sysroot_to_crate_graph");
 838     let mut cfg_options = CfgOptions::default();
 839     cfg_options.extend(rustc_cfg);
 840     let sysroot_crates: FxHashMap<SysrootCrate, CrateId> = sysroot
 841         .crates()
 842         .filter_map(|krate| {
 843             let file_id = load(&sysroot[krate].root)?;
 844
 845             let env = Env::default();
 846             let proc_macro = vec![];
 847             let display_name = CrateDisplayName::from_canonical_name(sysroot[krate].name.clone());
 848             let crate_id = crate_graph.add_crate_root(
 849                 file_id,
 850                 Edition::CURRENT,
 851                 Some(display_name),
 852                 cfg_options.clone(),
 853                 cfg_options.clone(),
 854                 env,
 855                 proc_macro,
 856             );
 857             Some((krate, crate_id))
 858         })
 859         .collect();
 860
 861     for from in sysroot.crates() {
 862         for &to in sysroot[from].deps.iter() {
 863             let name = CrateName::new(&sysroot[to].name).unwrap();
 864             if let (Some(&from), Some(&to)) = (sysroot_crates.get(&from), sysroot_crates.get(&to)) {
 865                 add_dep(crate_graph, from, name, to);
 866             }
 867         }
 868     }
 869
 870     let public_deps = sysroot
 871         .public_deps()
 872         .map(|(name, idx)| (CrateName::new(name).unwrap(), sysroot_crates[&idx]))
 873         .collect::<Vec<_>>();
 874
 875     let libproc_macro = sysroot.proc_macro().and_then(|it| sysroot_crates.get(&it).copied());
 876     (public_deps, libproc_macro)
 877 }
 878
 879 fn add_dep(graph: &mut CrateGraph, from: CrateId, name: CrateName, to: CrateId) {
 880     if let Err(err) = graph.add_dep(from, Dependency::new(name, to)) {
 881         tracing::error!("{}", err)
 882     }
 883 }
 884
 885 /// Recreates the compile-time environment variables that Cargo sets.
 886 ///
 887 /// Should be synced with
 888 /// <https://doc.rust-lang.org/cargo/reference/environment-variables.html#environment-variables-cargo-sets-for-crates>
 889 ///
 890 /// FIXME: ask Cargo to provide this data instead of re-deriving.
 891 fn inject_cargo_env(package: &PackageData, env: &mut Env) {
 892     // FIXME: Missing variables:
 893     // CARGO_BIN_NAME, CARGO_BIN_EXE_<name>
 894
 895     let manifest_dir = package.manifest.parent();
 896     env.set("CARGO_MANIFEST_DIR", manifest_dir.as_os_str().to_string_lossy().into_owned());
 897
 898     // Not always right, but works for common cases.
 899     env.set("CARGO", "cargo".into());
 900
 901     env.set("CARGO_PKG_VERSION", package.version.to_string());
 902     env.set("CARGO_PKG_VERSION_MAJOR", package.version.major.to_string());
 903     env.set("CARGO_PKG_VERSION_MINOR", package.version.minor.to_string());
 904     env.set("CARGO_PKG_VERSION_PATCH", package.version.patch.to_string());
 905     env.set("CARGO_PKG_VERSION_PRE", package.version.pre.to_string());
 906
 907     env.set("CARGO_PKG_AUTHORS", String::new());
 908
 909     env.set("CARGO_PKG_NAME", package.name.clone());
 910     // FIXME: This isn't really correct (a package can have many crates with different names), but
 911     // it's better than leaving the variable unset.
 912     env.set("CARGO_CRATE_NAME", CrateName::normalize_dashes(&package.name).to_string());
 913     env.set("CARGO_PKG_DESCRIPTION", String::new());
 914     env.set("CARGO_PKG_HOMEPAGE", String::new());
 915     env.set("CARGO_PKG_REPOSITORY", String::new());
 916     env.set("CARGO_PKG_LICENSE", String::new());
 917
 918     env.set("CARGO_PKG_LICENSE_FILE", String::new());
 919 }