diff options
Diffstat (limited to 'src/tools/rust-analyzer/crates/project-model')
25 files changed, 4655 insertions, 0 deletions
diff --git a/src/tools/rust-analyzer/crates/project-model/Cargo.toml b/src/tools/rust-analyzer/crates/project-model/Cargo.toml new file mode 100644 index 000000000..bc75d6faa --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/Cargo.toml @@ -0,0 +1,28 @@ +[package] +name = "project-model" +version = "0.0.0" +description = "TBD" +license = "MIT OR Apache-2.0" +edition = "2021" +rust-version = "1.57" + +[lib] +doctest = false + +[dependencies] +tracing = "0.1.35" +rustc-hash = "1.1.0" +cargo_metadata = "0.15.0" +semver = "1.0.10" +serde = { version = "1.0.137", features = ["derive"] } +serde_json = "1.0.81" +anyhow = "1.0.57" +expect-test = "1.4.0" +la-arena = { version = "0.3.0", path = "../../lib/la-arena" } + +cfg = { path = "../cfg", version = "0.0.0" } +base-db = { path = "../base-db", version = "0.0.0" } +toolchain = { path = "../toolchain", version = "0.0.0" } +paths = { path = "../paths", version = "0.0.0" } +stdx = { path = "../stdx", version = "0.0.0" } +profile = { path = "../profile", version = "0.0.0" } diff --git a/src/tools/rust-analyzer/crates/project-model/src/build_scripts.rs b/src/tools/rust-analyzer/crates/project-model/src/build_scripts.rs new file mode 100644 index 000000000..ee7f8339a --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/src/build_scripts.rs @@ -0,0 +1,238 @@ +//! Workspace information we get from cargo consists of two pieces. The first is +//! the output of `cargo metadata`. The second is the output of running +//! `build.rs` files (`OUT_DIR` env var, extra cfg flags) and compiling proc +//! macro. +//! +//! This module implements this second part. We use "build script" terminology +//! here, but it covers procedural macros as well. + +use std::{cell::RefCell, io, path::PathBuf, process::Command}; + +use cargo_metadata::{camino::Utf8Path, Message}; +use la_arena::ArenaMap; +use paths::AbsPathBuf; +use rustc_hash::FxHashMap; +use serde::Deserialize; + +use crate::{cfg_flag::CfgFlag, CargoConfig, CargoWorkspace, Package}; + +#[derive(Debug, Default, Clone, PartialEq, Eq)] +pub struct WorkspaceBuildScripts { + outputs: ArenaMap<Package, Option<BuildScriptOutput>>, + error: Option<String>, +} + +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub(crate) struct BuildScriptOutput { + /// List of config flags defined by this package's build script. + pub(crate) cfgs: Vec<CfgFlag>, + /// List of cargo-related environment variables with their value. + /// + /// If the package has a build script which defines environment variables, + /// they can also be found here. + pub(crate) envs: Vec<(String, String)>, + /// Directory where a build script might place its output. + pub(crate) out_dir: Option<AbsPathBuf>, + /// Path to the proc-macro library file if this package exposes proc-macros. + pub(crate) proc_macro_dylib_path: Option<AbsPathBuf>, +} + +impl WorkspaceBuildScripts { + fn build_command(config: &CargoConfig) -> Command { + if let Some([program, args @ ..]) = config.run_build_script_command.as_deref() { + let mut cmd = Command::new(program); + cmd.args(args); + return cmd; + } + + let mut cmd = Command::new(toolchain::cargo()); + + cmd.args(&["check", "--quiet", "--workspace", "--message-format=json"]); + + // --all-targets includes tests, benches and examples in addition to the + // default lib and bins. This is an independent concept from the --targets + // flag below. + cmd.arg("--all-targets"); + + if let Some(target) = &config.target { + cmd.args(&["--target", target]); + } + + if config.all_features { + cmd.arg("--all-features"); + } else { + if config.no_default_features { + cmd.arg("--no-default-features"); + } + if !config.features.is_empty() { + cmd.arg("--features"); + cmd.arg(config.features.join(" ")); + } + } + + cmd + } + + pub(crate) fn run( + config: &CargoConfig, + workspace: &CargoWorkspace, + progress: &dyn Fn(String), + ) -> io::Result<WorkspaceBuildScripts> { + let mut cmd = Self::build_command(config); + + if config.wrap_rustc_in_build_scripts { + // Setup RUSTC_WRAPPER to point to `rust-analyzer` binary itself. We use + // that to compile only proc macros and build scripts during the initial + // `cargo check`. + let myself = std::env::current_exe()?; + cmd.env("RUSTC_WRAPPER", myself); + cmd.env("RA_RUSTC_WRAPPER", "1"); + } + + cmd.current_dir(workspace.workspace_root()); + + let mut res = WorkspaceBuildScripts::default(); + let outputs = &mut res.outputs; + // NB: Cargo.toml could have been modified between `cargo metadata` and + // `cargo check`. We shouldn't assume that package ids we see here are + // exactly those from `config`. + let mut by_id: FxHashMap<String, Package> = FxHashMap::default(); + for package in workspace.packages() { + outputs.insert(package, None); + by_id.insert(workspace[package].id.clone(), package); + } + + let errors = RefCell::new(String::new()); + let push_err = |err: &str| { + let mut e = errors.borrow_mut(); + e.push_str(err); + e.push('\n'); + }; + + tracing::info!("Running build scripts: {:?}", cmd); + let output = stdx::process::spawn_with_streaming_output( + cmd, + &mut |line| { + // Copy-pasted from existing cargo_metadata. It seems like we + // should be using serde_stacker here? + let mut deserializer = serde_json::Deserializer::from_str(line); + deserializer.disable_recursion_limit(); + let message = Message::deserialize(&mut deserializer) + .unwrap_or_else(|_| Message::TextLine(line.to_string())); + + match message { + Message::BuildScriptExecuted(message) => { + let package = match by_id.get(&message.package_id.repr) { + Some(&it) => it, + None => return, + }; + let cfgs = { + let mut acc = Vec::new(); + for cfg in message.cfgs { + match cfg.parse::<CfgFlag>() { + Ok(it) => acc.push(it), + Err(err) => { + push_err(&format!( + "invalid cfg from cargo-metadata: {}", + err + )); + return; + } + }; + } + acc + }; + // cargo_metadata crate returns default (empty) path for + // older cargos, which is not absolute, so work around that. + let out_dir = message.out_dir.into_os_string(); + if !out_dir.is_empty() { + let data = outputs[package].get_or_insert_with(Default::default); + data.out_dir = Some(AbsPathBuf::assert(PathBuf::from(out_dir))); + data.cfgs = cfgs; + } + if !message.env.is_empty() { + outputs[package].get_or_insert_with(Default::default).envs = + message.env; + } + } + Message::CompilerArtifact(message) => { + let package = match by_id.get(&message.package_id.repr) { + Some(it) => *it, + None => return, + }; + + progress(format!("metadata {}", message.target.name)); + + if message.target.kind.iter().any(|k| k == "proc-macro") { + // Skip rmeta file + if let Some(filename) = + message.filenames.iter().find(|name| is_dylib(name)) + { + let filename = AbsPathBuf::assert(PathBuf::from(&filename)); + outputs[package] + .get_or_insert_with(Default::default) + .proc_macro_dylib_path = Some(filename); + } + } + } + Message::CompilerMessage(message) => { + progress(message.target.name); + + if let Some(diag) = message.message.rendered.as_deref() { + push_err(diag); + } + } + Message::BuildFinished(_) => {} + Message::TextLine(_) => {} + _ => {} + } + }, + &mut |line| { + push_err(line); + }, + )?; + + for package in workspace.packages() { + if let Some(package_build_data) = &mut outputs[package] { + tracing::info!( + "{}: {:?}", + workspace[package].manifest.parent().display(), + package_build_data, + ); + // inject_cargo_env(package, package_build_data); + if let Some(out_dir) = &package_build_data.out_dir { + // NOTE: cargo and rustc seem to hide non-UTF-8 strings from env! and option_env!() + if let Some(out_dir) = out_dir.as_os_str().to_str().map(|s| s.to_owned()) { + package_build_data.envs.push(("OUT_DIR".to_string(), out_dir)); + } + } + } + } + + let mut errors = errors.into_inner(); + if !output.status.success() { + if errors.is_empty() { + errors = "cargo check failed".to_string(); + } + res.error = Some(errors); + } + + Ok(res) + } + + pub fn error(&self) -> Option<&str> { + self.error.as_deref() + } + + pub(crate) fn get_output(&self, idx: Package) -> Option<&BuildScriptOutput> { + self.outputs.get(idx)?.as_ref() + } +} + +// FIXME: File a better way to know if it is a dylib. +fn is_dylib(path: &Utf8Path) -> bool { + match path.extension().map(|e| e.to_string().to_lowercase()) { + None => false, + Some(ext) => matches!(ext.as_str(), "dll" | "dylib" | "so"), + } +} diff --git a/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs b/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs new file mode 100644 index 000000000..597880c2c --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/src/cargo_workspace.rs @@ -0,0 +1,504 @@ +//! See [`CargoWorkspace`]. + +use std::iter; +use std::path::PathBuf; +use std::{ops, process::Command}; + +use anyhow::{Context, Result}; +use base_db::Edition; +use cargo_metadata::{CargoOpt, MetadataCommand}; +use la_arena::{Arena, Idx}; +use paths::{AbsPath, AbsPathBuf}; +use rustc_hash::FxHashMap; +use serde::Deserialize; +use serde_json::from_value; + +use crate::CfgOverrides; +use crate::{utf8_stdout, ManifestPath}; + +/// [`CargoWorkspace`] represents the logical structure of, well, a Cargo +/// workspace. It pretty closely mirrors `cargo metadata` output. +/// +/// Note that internally, rust analyzer uses a different structure: +/// `CrateGraph`. `CrateGraph` is lower-level: it knows only about the crates, +/// while this knows about `Packages` & `Targets`: purely cargo-related +/// concepts. +/// +/// We use absolute paths here, `cargo metadata` guarantees to always produce +/// abs paths. +#[derive(Debug, Clone, Eq, PartialEq)] +pub struct CargoWorkspace { + packages: Arena<PackageData>, + targets: Arena<TargetData>, + workspace_root: AbsPathBuf, +} + +impl ops::Index<Package> for CargoWorkspace { + type Output = PackageData; + fn index(&self, index: Package) -> &PackageData { + &self.packages[index] + } +} + +impl ops::Index<Target> for CargoWorkspace { + type Output = TargetData; + fn index(&self, index: Target) -> &TargetData { + &self.targets[index] + } +} + +/// Describes how to set the rustc source directory. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum RustcSource { + /// Explicit path for the rustc source directory. + Path(AbsPathBuf), + /// Try to automatically detect where the rustc source directory is. + Discover, +} + +/// Crates to disable `#[cfg(test)]` on. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum UnsetTestCrates { + None, + Only(Vec<String>), + All, +} + +impl Default for UnsetTestCrates { + fn default() -> Self { + Self::None + } +} + +#[derive(Default, Clone, Debug, PartialEq, Eq)] +pub struct CargoConfig { + /// Do not activate the `default` feature. + pub no_default_features: bool, + + /// Activate all available features + pub all_features: bool, + + /// List of features to activate. + /// This will be ignored if `cargo_all_features` is true. + pub features: Vec<String>, + + /// rustc target + pub target: Option<String>, + + /// Don't load sysroot crates (`std`, `core` & friends). Might be useful + /// when debugging isolated issues. + pub no_sysroot: bool, + + /// rustc private crate source + pub rustc_source: Option<RustcSource>, + + /// crates to disable `#[cfg(test)]` on + pub unset_test_crates: UnsetTestCrates, + + pub wrap_rustc_in_build_scripts: bool, + + pub run_build_script_command: Option<Vec<String>>, +} + +impl CargoConfig { + pub fn cfg_overrides(&self) -> CfgOverrides { + match &self.unset_test_crates { + UnsetTestCrates::None => CfgOverrides::Selective(iter::empty().collect()), + UnsetTestCrates::Only(unset_test_crates) => CfgOverrides::Selective( + unset_test_crates + .iter() + .cloned() + .zip(iter::repeat_with(|| { + cfg::CfgDiff::new(Vec::new(), vec![cfg::CfgAtom::Flag("test".into())]) + .unwrap() + })) + .collect(), + ), + UnsetTestCrates::All => CfgOverrides::Wildcard( + cfg::CfgDiff::new(Vec::new(), vec![cfg::CfgAtom::Flag("test".into())]).unwrap(), + ), + } + } +} + +pub type Package = Idx<PackageData>; + +pub type Target = Idx<TargetData>; + +/// Information associated with a cargo crate +#[derive(Debug, Clone, Eq, PartialEq)] +pub struct PackageData { + /// Version given in the `Cargo.toml` + pub version: semver::Version, + /// Name as given in the `Cargo.toml` + pub name: String, + /// Repository as given in the `Cargo.toml` + pub repository: Option<String>, + /// Path containing the `Cargo.toml` + pub manifest: ManifestPath, + /// Targets provided by the crate (lib, bin, example, test, ...) + pub targets: Vec<Target>, + /// Does this package come from the local filesystem (and is editable)? + pub is_local: bool, + // Whether this package is a member of the workspace + pub is_member: bool, + /// List of packages this package depends on + pub dependencies: Vec<PackageDependency>, + /// Rust edition for this package + pub edition: Edition, + /// Features provided by the crate, mapped to the features required by that feature. + pub features: FxHashMap<String, Vec<String>>, + /// List of features enabled on this package + pub active_features: Vec<String>, + /// String representation of package id + pub id: String, + /// The contents of [package.metadata.rust-analyzer] + pub metadata: RustAnalyzerPackageMetaData, +} + +#[derive(Deserialize, Default, Debug, Clone, Eq, PartialEq)] +pub struct RustAnalyzerPackageMetaData { + pub rustc_private: bool, +} + +#[derive(Debug, Clone, Eq, PartialEq)] +pub struct PackageDependency { + pub pkg: Package, + pub name: String, + pub kind: DepKind, +} + +#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord)] +pub enum DepKind { + /// Available to the library, binary, and dev targets in the package (but not the build script). + Normal, + /// Available only to test and bench targets (and the library target, when built with `cfg(test)`). + Dev, + /// Available only to the build script target. + Build, +} + +impl DepKind { + fn iter(list: &[cargo_metadata::DepKindInfo]) -> impl Iterator<Item = Self> + '_ { + let mut dep_kinds = Vec::new(); + if list.is_empty() { + dep_kinds.push(Self::Normal); + } + for info in list { + let kind = match info.kind { + cargo_metadata::DependencyKind::Normal => Self::Normal, + cargo_metadata::DependencyKind::Development => Self::Dev, + cargo_metadata::DependencyKind::Build => Self::Build, + cargo_metadata::DependencyKind::Unknown => continue, + }; + dep_kinds.push(kind); + } + dep_kinds.sort_unstable(); + dep_kinds.dedup(); + dep_kinds.into_iter() + } +} + +/// Information associated with a package's target +#[derive(Debug, Clone, Eq, PartialEq)] +pub struct TargetData { + /// Package that provided this target + pub package: Package, + /// Name as given in the `Cargo.toml` or generated from the file name + pub name: String, + /// Path to the main source file of the target + pub root: AbsPathBuf, + /// Kind of target + pub kind: TargetKind, + /// Is this target a proc-macro + pub is_proc_macro: bool, + /// Required features of the target without which it won't build + pub required_features: Vec<String>, +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum TargetKind { + Bin, + /// Any kind of Cargo lib crate-type (dylib, rlib, proc-macro, ...). + Lib, + Example, + Test, + Bench, + BuildScript, + Other, +} + +impl TargetKind { + fn new(kinds: &[String]) -> TargetKind { + for kind in kinds { + return match kind.as_str() { + "bin" => TargetKind::Bin, + "test" => TargetKind::Test, + "bench" => TargetKind::Bench, + "example" => TargetKind::Example, + "custom-build" => TargetKind::BuildScript, + "proc-macro" => TargetKind::Lib, + _ if kind.contains("lib") => TargetKind::Lib, + _ => continue, + }; + } + TargetKind::Other + } +} + +#[derive(Deserialize, Default)] +// Deserialise helper for the cargo metadata +struct PackageMetadata { + #[serde(rename = "rust-analyzer")] + rust_analyzer: Option<RustAnalyzerPackageMetaData>, +} + +impl CargoWorkspace { + pub fn fetch_metadata( + cargo_toml: &ManifestPath, + current_dir: &AbsPath, + config: &CargoConfig, + progress: &dyn Fn(String), + ) -> Result<cargo_metadata::Metadata> { + let target = config + .target + .clone() + .or_else(|| cargo_config_build_target(cargo_toml)) + .or_else(|| rustc_discover_host_triple(cargo_toml)); + + let mut meta = MetadataCommand::new(); + meta.cargo_path(toolchain::cargo()); + meta.manifest_path(cargo_toml.to_path_buf()); + if config.all_features { + meta.features(CargoOpt::AllFeatures); + } else { + if config.no_default_features { + // FIXME: `NoDefaultFeatures` is mutual exclusive with `SomeFeatures` + // https://github.com/oli-obk/cargo_metadata/issues/79 + meta.features(CargoOpt::NoDefaultFeatures); + } + if !config.features.is_empty() { + meta.features(CargoOpt::SomeFeatures(config.features.clone())); + } + } + meta.current_dir(current_dir.as_os_str()); + + if let Some(target) = target { + meta.other_options(vec![String::from("--filter-platform"), target]); + } + + // FIXME: Fetching metadata is a slow process, as it might require + // calling crates.io. We should be reporting progress here, but it's + // unclear whether cargo itself supports it. + progress("metadata".to_string()); + + let meta = + meta.exec().with_context(|| format!("Failed to run `{:?}`", meta.cargo_command()))?; + + Ok(meta) + } + + pub fn new(mut meta: cargo_metadata::Metadata) -> CargoWorkspace { + let mut pkg_by_id = FxHashMap::default(); + let mut packages = Arena::default(); + let mut targets = Arena::default(); + + let ws_members = &meta.workspace_members; + + meta.packages.sort_by(|a, b| a.id.cmp(&b.id)); + for meta_pkg in &meta.packages { + let cargo_metadata::Package { + id, + edition, + name, + manifest_path, + version, + metadata, + repository, + .. + } = meta_pkg; + let meta = from_value::<PackageMetadata>(metadata.clone()).unwrap_or_default(); + let edition = match edition { + cargo_metadata::Edition::E2015 => Edition::Edition2015, + cargo_metadata::Edition::E2018 => Edition::Edition2018, + cargo_metadata::Edition::E2021 => Edition::Edition2021, + _ => { + tracing::error!("Unsupported edition `{:?}`", edition); + Edition::CURRENT + } + }; + // We treat packages without source as "local" packages. That includes all members of + // the current workspace, as well as any path dependency outside the workspace. + let is_local = meta_pkg.source.is_none(); + let is_member = ws_members.contains(id); + + let pkg = packages.alloc(PackageData { + id: id.repr.clone(), + name: name.clone(), + version: version.clone(), + manifest: AbsPathBuf::assert(PathBuf::from(&manifest_path)).try_into().unwrap(), + targets: Vec::new(), + is_local, + is_member, + edition, + repository: repository.clone(), + dependencies: Vec::new(), + features: meta_pkg.features.clone().into_iter().collect(), + active_features: Vec::new(), + metadata: meta.rust_analyzer.unwrap_or_default(), + }); + let pkg_data = &mut packages[pkg]; + pkg_by_id.insert(id, pkg); + for meta_tgt in &meta_pkg.targets { + let is_proc_macro = meta_tgt.kind.as_slice() == ["proc-macro"]; + let tgt = targets.alloc(TargetData { + package: pkg, + name: meta_tgt.name.clone(), + root: AbsPathBuf::assert(PathBuf::from(&meta_tgt.src_path)), + kind: TargetKind::new(meta_tgt.kind.as_slice()), + is_proc_macro, + required_features: meta_tgt.required_features.clone(), + }); + pkg_data.targets.push(tgt); + } + } + let resolve = meta.resolve.expect("metadata executed with deps"); + for mut node in resolve.nodes { + let source = match pkg_by_id.get(&node.id) { + Some(&src) => src, + // FIXME: replace this and a similar branch below with `.unwrap`, once + // https://github.com/rust-lang/cargo/issues/7841 + // is fixed and hits stable (around 1.43-is probably?). + None => { + tracing::error!("Node id do not match in cargo metadata, ignoring {}", node.id); + continue; + } + }; + node.deps.sort_by(|a, b| a.pkg.cmp(&b.pkg)); + for (dep_node, kind) in node + .deps + .iter() + .flat_map(|dep| DepKind::iter(&dep.dep_kinds).map(move |kind| (dep, kind))) + { + let pkg = match pkg_by_id.get(&dep_node.pkg) { + Some(&pkg) => pkg, + None => { + tracing::error!( + "Dep node id do not match in cargo metadata, ignoring {}", + dep_node.pkg + ); + continue; + } + }; + let dep = PackageDependency { name: dep_node.name.clone(), pkg, kind }; + packages[source].dependencies.push(dep); + } + packages[source].active_features.extend(node.features); + } + + let workspace_root = + AbsPathBuf::assert(PathBuf::from(meta.workspace_root.into_os_string())); + + CargoWorkspace { packages, targets, workspace_root } + } + + pub fn packages<'a>(&'a self) -> impl Iterator<Item = Package> + ExactSizeIterator + 'a { + self.packages.iter().map(|(id, _pkg)| id) + } + + pub fn target_by_root(&self, root: &AbsPath) -> Option<Target> { + self.packages() + .filter(|&pkg| self[pkg].is_member) + .find_map(|pkg| self[pkg].targets.iter().find(|&&it| &self[it].root == root)) + .copied() + } + + pub fn workspace_root(&self) -> &AbsPath { + &self.workspace_root + } + + pub fn package_flag(&self, package: &PackageData) -> String { + if self.is_unique(&*package.name) { + package.name.clone() + } else { + format!("{}:{}", package.name, package.version) + } + } + + pub fn parent_manifests(&self, manifest_path: &ManifestPath) -> Option<Vec<ManifestPath>> { + let mut found = false; + let parent_manifests = self + .packages() + .filter_map(|pkg| { + if !found && &self[pkg].manifest == manifest_path { + found = true + } + self[pkg].dependencies.iter().find_map(|dep| { + if &self[dep.pkg].manifest == manifest_path { + return Some(self[pkg].manifest.clone()); + } + None + }) + }) + .collect::<Vec<ManifestPath>>(); + + // some packages has this pkg as dep. return their manifests + if parent_manifests.len() > 0 { + return Some(parent_manifests); + } + + // this pkg is inside this cargo workspace, fallback to workspace root + if found { + return Some(vec![ + ManifestPath::try_from(self.workspace_root().join("Cargo.toml")).ok()? + ]); + } + + // not in this workspace + None + } + + fn is_unique(&self, name: &str) -> bool { + self.packages.iter().filter(|(_, v)| v.name == name).count() == 1 + } +} + +fn rustc_discover_host_triple(cargo_toml: &ManifestPath) -> Option<String> { + let mut rustc = Command::new(toolchain::rustc()); + rustc.current_dir(cargo_toml.parent()).arg("-vV"); + tracing::debug!("Discovering host platform by {:?}", rustc); + match utf8_stdout(rustc) { + Ok(stdout) => { + let field = "host: "; + let target = stdout.lines().find_map(|l| l.strip_prefix(field)); + if let Some(target) = target { + Some(target.to_string()) + } else { + // If we fail to resolve the host platform, it's not the end of the world. + tracing::info!("rustc -vV did not report host platform, got:\n{}", stdout); + None + } + } + Err(e) => { + tracing::warn!("Failed to discover host platform: {}", e); + None + } + } +} + +fn cargo_config_build_target(cargo_toml: &ManifestPath) -> Option<String> { + let mut cargo_config = Command::new(toolchain::cargo()); + cargo_config + .current_dir(cargo_toml.parent()) + .args(&["-Z", "unstable-options", "config", "get", "build.target"]) + .env("RUSTC_BOOTSTRAP", "1"); + // if successful we receive `build.target = "target-triple"` + tracing::debug!("Discovering cargo config target by {:?}", cargo_config); + match utf8_stdout(cargo_config) { + Ok(stdout) => stdout + .strip_prefix("build.target = \"") + .and_then(|stdout| stdout.strip_suffix('"')) + .map(ToOwned::to_owned), + Err(_) => None, + } +} diff --git a/src/tools/rust-analyzer/crates/project-model/src/cfg_flag.rs b/src/tools/rust-analyzer/crates/project-model/src/cfg_flag.rs new file mode 100644 index 000000000..f3dd8f513 --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/src/cfg_flag.rs @@ -0,0 +1,63 @@ +//! Parsing of CfgFlags as command line arguments, as in +//! +//! rustc main.rs --cfg foo --cfg 'feature="bar"' +use std::{fmt, str::FromStr}; + +use cfg::CfgOptions; + +#[derive(Clone, Eq, PartialEq, Debug)] +pub enum CfgFlag { + Atom(String), + KeyValue { key: String, value: String }, +} + +impl FromStr for CfgFlag { + type Err = String; + fn from_str(s: &str) -> Result<Self, Self::Err> { + let res = match s.split_once('=') { + Some((key, value)) => { + if !(value.starts_with('"') && value.ends_with('"')) { + return Err(format!("Invalid cfg ({:?}), value should be in quotes", s)); + } + let key = key.to_string(); + let value = value[1..value.len() - 1].to_string(); + CfgFlag::KeyValue { key, value } + } + None => CfgFlag::Atom(s.into()), + }; + Ok(res) + } +} + +impl<'de> serde::Deserialize<'de> for CfgFlag { + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> + where + D: serde::Deserializer<'de>, + { + String::deserialize(deserializer)?.parse().map_err(serde::de::Error::custom) + } +} + +impl Extend<CfgFlag> for CfgOptions { + fn extend<T: IntoIterator<Item = CfgFlag>>(&mut self, iter: T) { + for cfg_flag in iter { + match cfg_flag { + CfgFlag::Atom(it) => self.insert_atom(it.into()), + CfgFlag::KeyValue { key, value } => self.insert_key_value(key.into(), value.into()), + } + } + } +} + +impl fmt::Display for CfgFlag { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + CfgFlag::Atom(atom) => f.write_str(atom), + CfgFlag::KeyValue { key, value } => { + f.write_str(key)?; + f.write_str("=")?; + f.write_str(value) + } + } + } +} diff --git a/src/tools/rust-analyzer/crates/project-model/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/src/lib.rs new file mode 100644 index 000000000..e3f83084a --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/src/lib.rs @@ -0,0 +1,159 @@ +//! In rust-analyzer, we maintain a strict separation between pure abstract +//! semantic project model and a concrete model of a particular build system. +//! +//! Pure model is represented by the [`base_db::CrateGraph`] from another crate. +//! +//! In this crate, we are conserned with "real world" project models. +//! +//! Specifically, here we have a representation for a Cargo project +//! ([`CargoWorkspace`]) and for manually specified layout ([`ProjectJson`]). +//! +//! Roughly, the things we do here are: +//! +//! * Project discovery (where's the relevant Cargo.toml for the current dir). +//! * Custom build steps (`build.rs` code generation and compilation of +//! procedural macros). +//! * Lowering of concrete model to a [`base_db::CrateGraph`] + +#![warn(rust_2018_idioms, unused_lifetimes, semicolon_in_expressions_from_macros)] + +mod manifest_path; +mod cargo_workspace; +mod cfg_flag; +mod project_json; +mod sysroot; +mod workspace; +mod rustc_cfg; +mod build_scripts; + +#[cfg(test)] +mod tests; + +use std::{ + fs::{self, read_dir, ReadDir}, + io, + process::Command, +}; + +use anyhow::{bail, format_err, Context, Result}; +use paths::{AbsPath, AbsPathBuf}; +use rustc_hash::FxHashSet; + +pub use crate::{ + build_scripts::WorkspaceBuildScripts, + cargo_workspace::{ + CargoConfig, CargoWorkspace, Package, PackageData, PackageDependency, RustcSource, Target, + TargetData, TargetKind, UnsetTestCrates, + }, + manifest_path::ManifestPath, + project_json::{ProjectJson, ProjectJsonData}, + sysroot::Sysroot, + workspace::{CfgOverrides, PackageRoot, ProjectWorkspace}, +}; + +#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)] +pub enum ProjectManifest { + ProjectJson(ManifestPath), + CargoToml(ManifestPath), +} + +impl ProjectManifest { + pub fn from_manifest_file(path: AbsPathBuf) -> Result<ProjectManifest> { + let path = ManifestPath::try_from(path) + .map_err(|path| format_err!("bad manifest path: {}", path.display()))?; + if path.file_name().unwrap_or_default() == "rust-project.json" { + return Ok(ProjectManifest::ProjectJson(path)); + } + if path.file_name().unwrap_or_default() == "Cargo.toml" { + return Ok(ProjectManifest::CargoToml(path)); + } + bail!("project root must point to Cargo.toml or rust-project.json: {}", path.display()) + } + + pub fn discover_single(path: &AbsPath) -> Result<ProjectManifest> { + let mut candidates = ProjectManifest::discover(path)?; + let res = match candidates.pop() { + None => bail!("no projects"), + Some(it) => it, + }; + + if !candidates.is_empty() { + bail!("more than one project") + } + Ok(res) + } + + pub fn discover(path: &AbsPath) -> io::Result<Vec<ProjectManifest>> { + if let Some(project_json) = find_in_parent_dirs(path, "rust-project.json") { + return Ok(vec![ProjectManifest::ProjectJson(project_json)]); + } + return find_cargo_toml(path) + .map(|paths| paths.into_iter().map(ProjectManifest::CargoToml).collect()); + + fn find_cargo_toml(path: &AbsPath) -> io::Result<Vec<ManifestPath>> { + match find_in_parent_dirs(path, "Cargo.toml") { + Some(it) => Ok(vec![it]), + None => Ok(find_cargo_toml_in_child_dir(read_dir(path)?)), + } + } + + fn find_in_parent_dirs(path: &AbsPath, target_file_name: &str) -> Option<ManifestPath> { + if path.file_name().unwrap_or_default() == target_file_name { + if let Ok(manifest) = ManifestPath::try_from(path.to_path_buf()) { + return Some(manifest); + } + } + + let mut curr = Some(path); + + while let Some(path) = curr { + let candidate = path.join(target_file_name); + if fs::metadata(&candidate).is_ok() { + if let Ok(manifest) = ManifestPath::try_from(candidate) { + return Some(manifest); + } + } + curr = path.parent(); + } + + None + } + + fn find_cargo_toml_in_child_dir(entities: ReadDir) -> Vec<ManifestPath> { + // Only one level down to avoid cycles the easy way and stop a runaway scan with large projects + entities + .filter_map(Result::ok) + .map(|it| it.path().join("Cargo.toml")) + .filter(|it| it.exists()) + .map(AbsPathBuf::assert) + .filter_map(|it| it.try_into().ok()) + .collect() + } + } + + pub fn discover_all(paths: &[AbsPathBuf]) -> Vec<ProjectManifest> { + let mut res = paths + .iter() + .filter_map(|it| ProjectManifest::discover(it.as_ref()).ok()) + .flatten() + .collect::<FxHashSet<_>>() + .into_iter() + .collect::<Vec<_>>(); + res.sort(); + res + } +} + +fn utf8_stdout(mut cmd: Command) -> Result<String> { + let output = cmd.output().with_context(|| format!("{:?} failed", cmd))?; + if !output.status.success() { + match String::from_utf8(output.stderr) { + Ok(stderr) if !stderr.is_empty() => { + bail!("{:?} failed, {}\nstderr:\n{}", cmd, output.status, stderr) + } + _ => bail!("{:?} failed, {}", cmd, output.status), + } + } + let stdout = String::from_utf8(output.stdout)?; + Ok(stdout.trim().to_string()) +} diff --git a/src/tools/rust-analyzer/crates/project-model/src/manifest_path.rs b/src/tools/rust-analyzer/crates/project-model/src/manifest_path.rs new file mode 100644 index 000000000..4910fd3d1 --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/src/manifest_path.rs @@ -0,0 +1,51 @@ +//! See [`ManifestPath`]. +use std::{ops, path::Path}; + +use paths::{AbsPath, AbsPathBuf}; + +/// More or less [`AbsPathBuf`] with non-None parent. +/// +/// We use it to store path to Cargo.toml, as we frequently use the parent dir +/// as a working directory to spawn various commands, and its nice to not have +/// to `.unwrap()` everywhere. +/// +/// This could have been named `AbsNonRootPathBuf`, as we don't enforce that +/// this stores manifest files in particular, but we only use this for manifests +/// at the moment in practice. +#[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)] +pub struct ManifestPath { + file: AbsPathBuf, +} + +impl TryFrom<AbsPathBuf> for ManifestPath { + type Error = AbsPathBuf; + + fn try_from(file: AbsPathBuf) -> Result<Self, Self::Error> { + if file.parent().is_none() { + Err(file) + } else { + Ok(ManifestPath { file }) + } + } +} + +impl ManifestPath { + // Shadow `parent` from `Deref`. + pub fn parent(&self) -> &AbsPath { + self.file.parent().unwrap() + } +} + +impl ops::Deref for ManifestPath { + type Target = AbsPath; + + fn deref(&self) -> &Self::Target { + &*self.file + } +} + +impl AsRef<Path> for ManifestPath { + fn as_ref(&self) -> &Path { + self.file.as_ref() + } +} diff --git a/src/tools/rust-analyzer/crates/project-model/src/project_json.rs b/src/tools/rust-analyzer/crates/project-model/src/project_json.rs new file mode 100644 index 000000000..63d1d0ace --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/src/project_json.rs @@ -0,0 +1,198 @@ +//! `rust-project.json` file format. +//! +//! This format is spiritually a serialization of [`base_db::CrateGraph`]. The +//! idea here is that people who do not use Cargo, can instead teach their build +//! system to generate `rust-project.json` which can be ingested by +//! rust-analyzer. + +use std::path::PathBuf; + +use base_db::{CrateDisplayName, CrateId, CrateName, Dependency, Edition}; +use paths::{AbsPath, AbsPathBuf}; +use rustc_hash::FxHashMap; +use serde::{de, Deserialize}; + +use crate::cfg_flag::CfgFlag; + +/// Roots and crates that compose this Rust project. +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct ProjectJson { + /// e.g. `path/to/sysroot` + pub(crate) sysroot: Option<AbsPathBuf>, + /// e.g. `path/to/sysroot/lib/rustlib/src/rust` + pub(crate) sysroot_src: Option<AbsPathBuf>, + project_root: AbsPathBuf, + crates: Vec<Crate>, +} + +/// A crate points to the root module of a crate and lists the dependencies of the crate. This is +/// useful in creating the crate graph. +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct Crate { + pub(crate) display_name: Option<CrateDisplayName>, + pub(crate) root_module: AbsPathBuf, + pub(crate) edition: Edition, + pub(crate) version: Option<String>, + pub(crate) deps: Vec<Dependency>, + pub(crate) cfg: Vec<CfgFlag>, + pub(crate) target: Option<String>, + pub(crate) env: FxHashMap<String, String>, + pub(crate) proc_macro_dylib_path: Option<AbsPathBuf>, + pub(crate) is_workspace_member: bool, + pub(crate) include: Vec<AbsPathBuf>, + pub(crate) exclude: Vec<AbsPathBuf>, + pub(crate) is_proc_macro: bool, + pub(crate) repository: Option<String>, +} + +impl ProjectJson { + /// Create a new ProjectJson instance. + /// + /// # Arguments + /// + /// * `base` - The path to the workspace root (i.e. the folder containing `rust-project.json`) + /// * `data` - The parsed contents of `rust-project.json`, or project json that's passed via + /// configuration. + pub fn new(base: &AbsPath, data: ProjectJsonData) -> ProjectJson { + ProjectJson { + sysroot: data.sysroot.map(|it| base.join(it)), + sysroot_src: data.sysroot_src.map(|it| base.join(it)), + project_root: base.to_path_buf(), + crates: data + .crates + .into_iter() + .map(|crate_data| { + let is_workspace_member = crate_data.is_workspace_member.unwrap_or_else(|| { + crate_data.root_module.is_relative() + && !crate_data.root_module.starts_with("..") + || crate_data.root_module.starts_with(base) + }); + let root_module = base.join(crate_data.root_module).normalize(); + let (include, exclude) = match crate_data.source { + Some(src) => { + let absolutize = |dirs: Vec<PathBuf>| { + dirs.into_iter() + .map(|it| base.join(it).normalize()) + .collect::<Vec<_>>() + }; + (absolutize(src.include_dirs), absolutize(src.exclude_dirs)) + } + None => (vec![root_module.parent().unwrap().to_path_buf()], Vec::new()), + }; + + Crate { + display_name: crate_data + .display_name + .map(CrateDisplayName::from_canonical_name), + root_module, + edition: crate_data.edition.into(), + version: crate_data.version.as_ref().map(ToString::to_string), + deps: crate_data + .deps + .into_iter() + .map(|dep_data| { + Dependency::new(dep_data.name, CrateId(dep_data.krate as u32)) + }) + .collect::<Vec<_>>(), + cfg: crate_data.cfg, + target: crate_data.target, + env: crate_data.env, + proc_macro_dylib_path: crate_data + .proc_macro_dylib_path + .map(|it| base.join(it)), + is_workspace_member, + include, + exclude, + is_proc_macro: crate_data.is_proc_macro, + repository: crate_data.repository, + } + }) + .collect::<Vec<_>>(), + } + } + /// Returns the number of crates in the project. + pub fn n_crates(&self) -> usize { + self.crates.len() + } + /// Returns an iterator over the crates in the project. + pub fn crates(&self) -> impl Iterator<Item = (CrateId, &Crate)> + '_ { + self.crates.iter().enumerate().map(|(idx, krate)| (CrateId(idx as u32), krate)) + } + /// Returns the path to the project's root folder. + pub fn path(&self) -> &AbsPath { + &self.project_root + } +} + +#[derive(Deserialize, Debug, Clone)] +pub struct ProjectJsonData { + sysroot: Option<PathBuf>, + sysroot_src: Option<PathBuf>, + crates: Vec<CrateData>, +} + +#[derive(Deserialize, Debug, Clone)] +struct CrateData { + display_name: Option<String>, + root_module: PathBuf, + edition: EditionData, + #[serde(default)] + version: Option<semver::Version>, + deps: Vec<DepData>, + #[serde(default)] + cfg: Vec<CfgFlag>, + target: Option<String>, + #[serde(default)] + env: FxHashMap<String, String>, + proc_macro_dylib_path: Option<PathBuf>, + is_workspace_member: Option<bool>, + source: Option<CrateSource>, + #[serde(default)] + is_proc_macro: bool, + #[serde(default)] + repository: Option<String>, +} + +#[derive(Deserialize, Debug, Clone)] +#[serde(rename = "edition")] +enum EditionData { + #[serde(rename = "2015")] + Edition2015, + #[serde(rename = "2018")] + Edition2018, + #[serde(rename = "2021")] + Edition2021, +} + +impl From<EditionData> for Edition { + fn from(data: EditionData) -> Self { + match data { + EditionData::Edition2015 => Edition::Edition2015, + EditionData::Edition2018 => Edition::Edition2018, + EditionData::Edition2021 => Edition::Edition2021, + } + } +} + +#[derive(Deserialize, Debug, Clone)] +struct DepData { + /// Identifies a crate by position in the crates array. + #[serde(rename = "crate")] + krate: usize, + #[serde(deserialize_with = "deserialize_crate_name")] + name: CrateName, +} + +#[derive(Deserialize, Debug, Clone)] +struct CrateSource { + include_dirs: Vec<PathBuf>, + exclude_dirs: Vec<PathBuf>, +} + +fn deserialize_crate_name<'de, D>(de: D) -> Result<CrateName, D::Error> +where + D: de::Deserializer<'de>, +{ + let name = String::deserialize(de)?; + CrateName::new(&name).map_err(|err| de::Error::custom(format!("invalid crate name: {:?}", err))) +} diff --git a/src/tools/rust-analyzer/crates/project-model/src/rustc_cfg.rs b/src/tools/rust-analyzer/crates/project-model/src/rustc_cfg.rs new file mode 100644 index 000000000..17e244d06 --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/src/rustc_cfg.rs @@ -0,0 +1,60 @@ +//! Runs `rustc --print cfg` to get built-in cfg flags. + +use std::process::Command; + +use anyhow::Result; + +use crate::{cfg_flag::CfgFlag, utf8_stdout, ManifestPath}; + +pub(crate) fn get(cargo_toml: Option<&ManifestPath>, target: Option<&str>) -> Vec<CfgFlag> { + let _p = profile::span("rustc_cfg::get"); + let mut res = Vec::with_capacity(6 * 2 + 1); + + // Some nightly-only cfgs, which are required for stdlib + res.push(CfgFlag::Atom("target_thread_local".into())); + for ty in ["8", "16", "32", "64", "cas", "ptr"] { + for key in ["target_has_atomic", "target_has_atomic_load_store"] { + res.push(CfgFlag::KeyValue { key: key.to_string(), value: ty.into() }); + } + } + + match get_rust_cfgs(cargo_toml, target) { + Ok(rustc_cfgs) => { + tracing::debug!( + "rustc cfgs found: {:?}", + rustc_cfgs + .lines() + .map(|it| it.parse::<CfgFlag>().map(|it| it.to_string())) + .collect::<Vec<_>>() + ); + res.extend(rustc_cfgs.lines().filter_map(|it| it.parse().ok())); + } + Err(e) => tracing::error!("failed to get rustc cfgs: {e:?}"), + } + + res +} + +fn get_rust_cfgs(cargo_toml: Option<&ManifestPath>, target: Option<&str>) -> Result<String> { + if let Some(cargo_toml) = cargo_toml { + let mut cargo_config = Command::new(toolchain::cargo()); + cargo_config + .current_dir(cargo_toml.parent()) + .args(&["-Z", "unstable-options", "rustc", "--print", "cfg"]) + .env("RUSTC_BOOTSTRAP", "1"); + if let Some(target) = target { + cargo_config.args(&["--target", target]); + } + match utf8_stdout(cargo_config) { + Ok(it) => return Ok(it), + Err(e) => tracing::debug!("{e:?}: falling back to querying rustc for cfgs"), + } + } + // using unstable cargo features failed, fall back to using plain rustc + let mut cmd = Command::new(toolchain::rustc()); + cmd.args(&["--print", "cfg", "-O"]); + if let Some(target) = target { + cmd.args(&["--target", target]); + } + utf8_stdout(cmd) +} diff --git a/src/tools/rust-analyzer/crates/project-model/src/sysroot.rs b/src/tools/rust-analyzer/crates/project-model/src/sysroot.rs new file mode 100644 index 000000000..362bb0f5e --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/src/sysroot.rs @@ -0,0 +1,232 @@ +//! Loads "sysroot" crate. +//! +//! One confusing point here is that normally sysroot is a bunch of `.rlib`s, +//! but we can't process `.rlib` and need source code instead. The source code +//! is typically installed with `rustup component add rust-src` command. + +use std::{env, fs, iter, ops, path::PathBuf, process::Command}; + +use anyhow::{format_err, Result}; +use la_arena::{Arena, Idx}; +use paths::{AbsPath, AbsPathBuf}; + +use crate::{utf8_stdout, ManifestPath}; + +#[derive(Debug, Clone, Eq, PartialEq)] +pub struct Sysroot { + root: AbsPathBuf, + src_root: AbsPathBuf, + crates: Arena<SysrootCrateData>, +} + +pub(crate) type SysrootCrate = Idx<SysrootCrateData>; + +#[derive(Debug, Clone, Eq, PartialEq)] +pub struct SysrootCrateData { + pub name: String, + pub root: ManifestPath, + pub deps: Vec<SysrootCrate>, +} + +impl ops::Index<SysrootCrate> for Sysroot { + type Output = SysrootCrateData; + fn index(&self, index: SysrootCrate) -> &SysrootCrateData { + &self.crates[index] + } +} + +impl Sysroot { + /// Returns sysroot "root" directory, where `bin/`, `etc/`, `lib/`, `libexec/` + /// subfolder live, like: + /// `$HOME/.rustup/toolchains/nightly-2022-07-23-x86_64-unknown-linux-gnu` + pub fn root(&self) -> &AbsPath { + &self.root + } + + /// Returns the sysroot "source" directory, where stdlib sources are located, like: + /// `$HOME/.rustup/toolchains/nightly-2022-07-23-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library` + pub fn src_root(&self) -> &AbsPath { + &self.src_root + } + + pub fn public_deps(&self) -> impl Iterator<Item = (&'static str, SysrootCrate, bool)> + '_ { + // core is added as a dependency before std in order to + // mimic rustcs dependency order + ["core", "alloc", "std"] + .into_iter() + .zip(iter::repeat(true)) + .chain(iter::once(("test", false))) + .filter_map(move |(name, prelude)| Some((name, self.by_name(name)?, prelude))) + } + + pub fn proc_macro(&self) -> Option<SysrootCrate> { + self.by_name("proc_macro") + } + + pub fn crates<'a>(&'a self) -> impl Iterator<Item = SysrootCrate> + ExactSizeIterator + 'a { + self.crates.iter().map(|(id, _data)| id) + } + + pub fn discover(dir: &AbsPath) -> Result<Sysroot> { + tracing::debug!("Discovering sysroot for {}", dir.display()); + let sysroot_dir = discover_sysroot_dir(dir)?; + let sysroot_src_dir = discover_sysroot_src_dir(&sysroot_dir, dir)?; + let res = Sysroot::load(sysroot_dir, sysroot_src_dir)?; + Ok(res) + } + + pub fn discover_rustc(cargo_toml: &ManifestPath) -> Option<ManifestPath> { + tracing::debug!("Discovering rustc source for {}", cargo_toml.display()); + let current_dir = cargo_toml.parent(); + discover_sysroot_dir(current_dir).ok().and_then(|sysroot_dir| get_rustc_src(&sysroot_dir)) + } + + pub fn load(sysroot_dir: AbsPathBuf, sysroot_src_dir: AbsPathBuf) -> Result<Sysroot> { + let mut sysroot = + Sysroot { root: sysroot_dir, src_root: sysroot_src_dir, crates: Arena::default() }; + + for path in SYSROOT_CRATES.trim().lines() { + let name = path.split('/').last().unwrap(); + let root = [format!("{}/src/lib.rs", path), format!("lib{}/lib.rs", path)] + .into_iter() + .map(|it| sysroot.src_root.join(it)) + .filter_map(|it| ManifestPath::try_from(it).ok()) + .find(|it| fs::metadata(it).is_ok()); + + if let Some(root) = root { + sysroot.crates.alloc(SysrootCrateData { + name: name.into(), + root, + deps: Vec::new(), + }); + } + } + + if let Some(std) = sysroot.by_name("std") { + for dep in STD_DEPS.trim().lines() { + if let Some(dep) = sysroot.by_name(dep) { + sysroot.crates[std].deps.push(dep) + } + } + } + + if let Some(alloc) = sysroot.by_name("alloc") { + if let Some(core) = sysroot.by_name("core") { + sysroot.crates[alloc].deps.push(core); + } + } + + if let Some(proc_macro) = sysroot.by_name("proc_macro") { + if let Some(std) = sysroot.by_name("std") { + sysroot.crates[proc_macro].deps.push(std); + } + } + + if sysroot.by_name("core").is_none() { + let var_note = if env::var_os("RUST_SRC_PATH").is_some() { + " (`RUST_SRC_PATH` might be incorrect, try unsetting it)" + } else { + "" + }; + anyhow::bail!( + "could not find libcore in sysroot path `{}`{}", + sysroot.src_root.as_path().display(), + var_note, + ); + } + + Ok(sysroot) + } + + fn by_name(&self, name: &str) -> Option<SysrootCrate> { + let (id, _data) = self.crates.iter().find(|(_id, data)| data.name == name)?; + Some(id) + } +} + +fn discover_sysroot_dir(current_dir: &AbsPath) -> Result<AbsPathBuf> { + let mut rustc = Command::new(toolchain::rustc()); + rustc.current_dir(current_dir).args(&["--print", "sysroot"]); + tracing::debug!("Discovering sysroot by {:?}", rustc); + let stdout = utf8_stdout(rustc)?; + Ok(AbsPathBuf::assert(PathBuf::from(stdout))) +} + +fn discover_sysroot_src_dir( + sysroot_path: &AbsPathBuf, + current_dir: &AbsPath, +) -> Result<AbsPathBuf> { + if let Ok(path) = env::var("RUST_SRC_PATH") { + let path = AbsPathBuf::try_from(path.as_str()) + .map_err(|path| format_err!("RUST_SRC_PATH must be absolute: {}", path.display()))?; + let core = path.join("core"); + if fs::metadata(&core).is_ok() { + tracing::debug!("Discovered sysroot by RUST_SRC_PATH: {}", path.display()); + return Ok(path); + } + tracing::debug!("RUST_SRC_PATH is set, but is invalid (no core: {:?}), ignoring", core); + } + + get_rust_src(sysroot_path) + .or_else(|| { + let mut rustup = Command::new(toolchain::rustup()); + rustup.current_dir(current_dir).args(&["component", "add", "rust-src"]); + utf8_stdout(rustup).ok()?; + get_rust_src(sysroot_path) + }) + .ok_or_else(|| { + format_err!( + "\ +can't load standard library from sysroot +{} +(discovered via `rustc --print sysroot`) +try installing the Rust source the same way you installed rustc", + sysroot_path.display(), + ) + }) +} + +fn get_rustc_src(sysroot_path: &AbsPath) -> Option<ManifestPath> { + let rustc_src = sysroot_path.join("lib/rustlib/rustc-src/rust/compiler/rustc/Cargo.toml"); + let rustc_src = ManifestPath::try_from(rustc_src).ok()?; + tracing::debug!("Checking for rustc source code: {}", rustc_src.display()); + if fs::metadata(&rustc_src).is_ok() { + Some(rustc_src) + } else { + None + } +} + +fn get_rust_src(sysroot_path: &AbsPath) -> Option<AbsPathBuf> { + let rust_src = sysroot_path.join("lib/rustlib/src/rust/library"); + tracing::debug!("Checking sysroot: {}", rust_src.display()); + if fs::metadata(&rust_src).is_ok() { + Some(rust_src) + } else { + None + } +} + +const SYSROOT_CRATES: &str = " +alloc +core +panic_abort +panic_unwind +proc_macro +profiler_builtins +std +stdarch/crates/std_detect +term +test +unwind"; + +const STD_DEPS: &str = " +alloc +core +panic_abort +panic_unwind +profiler_builtins +std_detect +term +test +unwind"; diff --git a/src/tools/rust-analyzer/crates/project-model/src/tests.rs b/src/tools/rust-analyzer/crates/project-model/src/tests.rs new file mode 100644 index 000000000..e304a59c0 --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/src/tests.rs @@ -0,0 +1,1820 @@ +use std::{ + ops::Deref, + path::{Path, PathBuf}, +}; + +use base_db::{CrateGraph, FileId}; +use cfg::{CfgAtom, CfgDiff}; +use expect_test::{expect, Expect}; +use paths::{AbsPath, AbsPathBuf}; +use serde::de::DeserializeOwned; + +use crate::{ + CargoWorkspace, CfgOverrides, ProjectJson, ProjectJsonData, ProjectWorkspace, Sysroot, + WorkspaceBuildScripts, +}; + +fn load_cargo(file: &str) -> CrateGraph { + load_cargo_with_overrides(file, CfgOverrides::default()) +} + +fn load_cargo_with_overrides(file: &str, cfg_overrides: CfgOverrides) -> CrateGraph { + let meta = get_test_json_file(file); + let cargo_workspace = CargoWorkspace::new(meta); + let project_workspace = ProjectWorkspace::Cargo { + cargo: cargo_workspace, + build_scripts: WorkspaceBuildScripts::default(), + sysroot: None, + rustc: None, + rustc_cfg: Vec::new(), + cfg_overrides, + }; + to_crate_graph(project_workspace) +} + +fn load_rust_project(file: &str) -> CrateGraph { + let data = get_test_json_file(file); + let project = rooted_project_json(data); + let sysroot = Some(get_fake_sysroot()); + let project_workspace = ProjectWorkspace::Json { project, sysroot, rustc_cfg: Vec::new() }; + to_crate_graph(project_workspace) +} + +fn get_test_json_file<T: DeserializeOwned>(file: &str) -> T { + let file = get_test_path(file); + let data = std::fs::read_to_string(file).unwrap(); + let mut json = data.parse::<serde_json::Value>().unwrap(); + fixup_paths(&mut json); + return serde_json::from_value(json).unwrap(); + + fn fixup_paths(val: &mut serde_json::Value) { + match val { + serde_json::Value::String(s) => replace_root(s, true), + serde_json::Value::Array(vals) => vals.iter_mut().for_each(fixup_paths), + serde_json::Value::Object(kvals) => kvals.values_mut().for_each(fixup_paths), + serde_json::Value::Null | serde_json::Value::Bool(_) | serde_json::Value::Number(_) => { + } + } + } +} + +fn replace_root(s: &mut String, direction: bool) { + if direction { + let root = if cfg!(windows) { r#"C:\\ROOT\"# } else { "/ROOT/" }; + *s = s.replace("$ROOT$", root) + } else { + let root = if cfg!(windows) { r#"C:\\\\ROOT\\"# } else { "/ROOT/" }; + *s = s.replace(root, "$ROOT$") + } +} + +fn get_test_path(file: &str) -> PathBuf { + let base = PathBuf::from(env!("CARGO_MANIFEST_DIR")); + base.join("test_data").join(file) +} + +fn get_fake_sysroot() -> Sysroot { + let sysroot_path = get_test_path("fake-sysroot"); + // there's no `libexec/` directory with a `proc-macro-srv` binary in that + // fake sysroot, so we give them both the same path: + let sysroot_dir = AbsPathBuf::assert(sysroot_path); + let sysroot_src_dir = sysroot_dir.clone(); + Sysroot::load(sysroot_dir, sysroot_src_dir).unwrap() +} + +fn rooted_project_json(data: ProjectJsonData) -> ProjectJson { + let mut root = "$ROOT$".to_string(); + replace_root(&mut root, true); + let path = Path::new(&root); + let base = AbsPath::assert(path); + ProjectJson::new(base, data) +} + +fn to_crate_graph(project_workspace: ProjectWorkspace) -> CrateGraph { + project_workspace.to_crate_graph(&mut |_, _| Ok(Vec::new()), &mut { + let mut counter = 0; + move |_path| { + counter += 1; + Some(FileId(counter)) + } + }) +} + +fn check_crate_graph(crate_graph: CrateGraph, expect: Expect) { + let mut crate_graph = format!("{:#?}", crate_graph); + replace_root(&mut crate_graph, false); + expect.assert_eq(&crate_graph); +} + +#[test] +fn cargo_hello_world_project_model_with_wildcard_overrides() { + let cfg_overrides = CfgOverrides::Wildcard( + CfgDiff::new(Vec::new(), vec![CfgAtom::Flag("test".into())]).unwrap(), + ); + let crate_graph = load_cargo_with_overrides("hello-world-metadata.json", cfg_overrides); + check_crate_graph( + crate_graph, + expect![[r#" + CrateGraph { + arena: { + CrateId( + 0, + ): CrateData { + root_file_id: FileId( + 1, + ), + edition: Edition2018, + version: Some( + "0.1.0", + ), + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "hello_world", + ), + canonical_name: "hello-world", + }, + ), + cfg_options: CfgOptions( + [ + "debug_assertions", + ], + ), + potential_cfg_options: CfgOptions( + [ + "debug_assertions", + ], + ), + env: Env { + entries: { + "CARGO_PKG_LICENSE": "", + "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_PKG_LICENSE_FILE": "", + "CARGO_PKG_HOMEPAGE": "", + "CARGO_PKG_DESCRIPTION": "", + "CARGO_PKG_NAME": "hello-world", + "CARGO_PKG_VERSION_PATCH": "0", + "CARGO": "cargo", + "CARGO_PKG_REPOSITORY": "", + "CARGO_PKG_VERSION_MINOR": "1", + "CARGO_PKG_VERSION_PRE": "", + }, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 4, + ), + name: CrateName( + "libc", + ), + prelude: true, + }, + ], + proc_macro: Err( + "crate has not (yet) been built", + ), + origin: CratesIo { + repo: None, + }, + is_proc_macro: false, + }, + CrateId( + 2, + ): CrateData { + root_file_id: FileId( + 3, + ), + edition: Edition2018, + version: Some( + "0.1.0", + ), + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "an_example", + ), + canonical_name: "an-example", + }, + ), + cfg_options: CfgOptions( + [ + "debug_assertions", + ], + ), + potential_cfg_options: CfgOptions( + [ + "debug_assertions", + ], + ), + env: Env { + entries: { + "CARGO_PKG_LICENSE": "", + "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_PKG_LICENSE_FILE": "", + "CARGO_PKG_HOMEPAGE": "", + "CARGO_PKG_DESCRIPTION": "", + "CARGO_PKG_NAME": "hello-world", + "CARGO_PKG_VERSION_PATCH": "0", + "CARGO": "cargo", + "CARGO_PKG_REPOSITORY": "", + "CARGO_PKG_VERSION_MINOR": "1", + "CARGO_PKG_VERSION_PRE": "", + }, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 0, + ), + name: CrateName( + "hello_world", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 4, + ), + name: CrateName( + "libc", + ), + prelude: true, + }, + ], + proc_macro: Err( + "crate has not (yet) been built", + ), + origin: CratesIo { + repo: None, + }, + is_proc_macro: false, + }, + CrateId( + 4, + ): CrateData { + root_file_id: FileId( + 5, + ), + edition: Edition2015, + version: Some( + "0.2.98", + ), + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "libc", + ), + canonical_name: "libc", + }, + ), + cfg_options: CfgOptions( + [ + "debug_assertions", + "feature=default", + "feature=std", + ], + ), + potential_cfg_options: CfgOptions( + [ + "debug_assertions", + "feature=align", + "feature=const-extern-fn", + "feature=default", + "feature=extra_traits", + "feature=rustc-dep-of-std", + "feature=std", + "feature=use_std", + ], + ), + env: Env { + entries: { + "CARGO_PKG_LICENSE": "", + "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_PKG_LICENSE_FILE": "", + "CARGO_PKG_HOMEPAGE": "", + "CARGO_PKG_DESCRIPTION": "", + "CARGO_PKG_NAME": "libc", + "CARGO_PKG_VERSION_PATCH": "98", + "CARGO": "cargo", + "CARGO_PKG_REPOSITORY": "", + "CARGO_PKG_VERSION_MINOR": "2", + "CARGO_PKG_VERSION_PRE": "", + }, + }, + dependencies: [], + proc_macro: Err( + "crate has not (yet) been built", + ), + origin: CratesIo { + repo: Some( + "https://github.com/rust-lang/libc", + ), + }, + is_proc_macro: false, + }, + CrateId( + 1, + ): CrateData { + root_file_id: FileId( + 2, + ), + edition: Edition2018, + version: Some( + "0.1.0", + ), + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "hello_world", + ), + canonical_name: "hello-world", + }, + ), + cfg_options: CfgOptions( + [ + "debug_assertions", + ], + ), + potential_cfg_options: CfgOptions( + [ + "debug_assertions", + ], + ), + env: Env { + entries: { + "CARGO_PKG_LICENSE": "", + "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_PKG_LICENSE_FILE": "", + "CARGO_PKG_HOMEPAGE": "", + "CARGO_PKG_DESCRIPTION": "", + "CARGO_PKG_NAME": "hello-world", + "CARGO_PKG_VERSION_PATCH": "0", + "CARGO": "cargo", + "CARGO_PKG_REPOSITORY": "", + "CARGO_PKG_VERSION_MINOR": "1", + "CARGO_PKG_VERSION_PRE": "", + }, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 0, + ), + name: CrateName( + "hello_world", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 4, + ), + name: CrateName( + "libc", + ), + prelude: true, + }, + ], + proc_macro: Err( + "crate has not (yet) been built", + ), + origin: CratesIo { + repo: None, + }, + is_proc_macro: false, + }, + CrateId( + 3, + ): CrateData { + root_file_id: FileId( + 4, + ), + edition: Edition2018, + version: Some( + "0.1.0", + ), + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "it", + ), + canonical_name: "it", + }, + ), + cfg_options: CfgOptions( + [ + "debug_assertions", + ], + ), + potential_cfg_options: CfgOptions( + [ + "debug_assertions", + ], + ), + env: Env { + entries: { + "CARGO_PKG_LICENSE": "", + "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_PKG_LICENSE_FILE": "", + "CARGO_PKG_HOMEPAGE": "", + "CARGO_PKG_DESCRIPTION": "", + "CARGO_PKG_NAME": "hello-world", + "CARGO_PKG_VERSION_PATCH": "0", + "CARGO": "cargo", + "CARGO_PKG_REPOSITORY": "", + "CARGO_PKG_VERSION_MINOR": "1", + "CARGO_PKG_VERSION_PRE": "", + }, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 0, + ), + name: CrateName( + "hello_world", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 4, + ), + name: CrateName( + "libc", + ), + prelude: true, + }, + ], + proc_macro: Err( + "crate has not (yet) been built", + ), + origin: CratesIo { + repo: None, + }, + is_proc_macro: false, + }, + }, + }"#]], + ) +} + +#[test] +fn cargo_hello_world_project_model_with_selective_overrides() { + let cfg_overrides = { + CfgOverrides::Selective( + std::iter::once(( + "libc".to_owned(), + CfgDiff::new(Vec::new(), vec![CfgAtom::Flag("test".into())]).unwrap(), + )) + .collect(), + ) + }; + let crate_graph = load_cargo_with_overrides("hello-world-metadata.json", cfg_overrides); + check_crate_graph( + crate_graph, + expect![[r#" + CrateGraph { + arena: { + CrateId( + 0, + ): CrateData { + root_file_id: FileId( + 1, + ), + edition: Edition2018, + version: Some( + "0.1.0", + ), + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "hello_world", + ), + canonical_name: "hello-world", + }, + ), + cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + potential_cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + env: Env { + entries: { + "CARGO_PKG_LICENSE": "", + "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_PKG_LICENSE_FILE": "", + "CARGO_PKG_HOMEPAGE": "", + "CARGO_PKG_DESCRIPTION": "", + "CARGO_PKG_NAME": "hello-world", + "CARGO_PKG_VERSION_PATCH": "0", + "CARGO": "cargo", + "CARGO_PKG_REPOSITORY": "", + "CARGO_PKG_VERSION_MINOR": "1", + "CARGO_PKG_VERSION_PRE": "", + }, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 4, + ), + name: CrateName( + "libc", + ), + prelude: true, + }, + ], + proc_macro: Err( + "crate has not (yet) been built", + ), + origin: CratesIo { + repo: None, + }, + is_proc_macro: false, + }, + CrateId( + 2, + ): CrateData { + root_file_id: FileId( + 3, + ), + edition: Edition2018, + version: Some( + "0.1.0", + ), + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "an_example", + ), + canonical_name: "an-example", + }, + ), + cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + potential_cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + env: Env { + entries: { + "CARGO_PKG_LICENSE": "", + "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_PKG_LICENSE_FILE": "", + "CARGO_PKG_HOMEPAGE": "", + "CARGO_PKG_DESCRIPTION": "", + "CARGO_PKG_NAME": "hello-world", + "CARGO_PKG_VERSION_PATCH": "0", + "CARGO": "cargo", + "CARGO_PKG_REPOSITORY": "", + "CARGO_PKG_VERSION_MINOR": "1", + "CARGO_PKG_VERSION_PRE": "", + }, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 0, + ), + name: CrateName( + "hello_world", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 4, + ), + name: CrateName( + "libc", + ), + prelude: true, + }, + ], + proc_macro: Err( + "crate has not (yet) been built", + ), + origin: CratesIo { + repo: None, + }, + is_proc_macro: false, + }, + CrateId( + 4, + ): CrateData { + root_file_id: FileId( + 5, + ), + edition: Edition2015, + version: Some( + "0.2.98", + ), + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "libc", + ), + canonical_name: "libc", + }, + ), + cfg_options: CfgOptions( + [ + "debug_assertions", + "feature=default", + "feature=std", + ], + ), + potential_cfg_options: CfgOptions( + [ + "debug_assertions", + "feature=align", + "feature=const-extern-fn", + "feature=default", + "feature=extra_traits", + "feature=rustc-dep-of-std", + "feature=std", + "feature=use_std", + ], + ), + env: Env { + entries: { + "CARGO_PKG_LICENSE": "", + "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_PKG_LICENSE_FILE": "", + "CARGO_PKG_HOMEPAGE": "", + "CARGO_PKG_DESCRIPTION": "", + "CARGO_PKG_NAME": "libc", + "CARGO_PKG_VERSION_PATCH": "98", + "CARGO": "cargo", + "CARGO_PKG_REPOSITORY": "", + "CARGO_PKG_VERSION_MINOR": "2", + "CARGO_PKG_VERSION_PRE": "", + }, + }, + dependencies: [], + proc_macro: Err( + "crate has not (yet) been built", + ), + origin: CratesIo { + repo: Some( + "https://github.com/rust-lang/libc", + ), + }, + is_proc_macro: false, + }, + CrateId( + 1, + ): CrateData { + root_file_id: FileId( + 2, + ), + edition: Edition2018, + version: Some( + "0.1.0", + ), + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "hello_world", + ), + canonical_name: "hello-world", + }, + ), + cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + potential_cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + env: Env { + entries: { + "CARGO_PKG_LICENSE": "", + "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_PKG_LICENSE_FILE": "", + "CARGO_PKG_HOMEPAGE": "", + "CARGO_PKG_DESCRIPTION": "", + "CARGO_PKG_NAME": "hello-world", + "CARGO_PKG_VERSION_PATCH": "0", + "CARGO": "cargo", + "CARGO_PKG_REPOSITORY": "", + "CARGO_PKG_VERSION_MINOR": "1", + "CARGO_PKG_VERSION_PRE": "", + }, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 0, + ), + name: CrateName( + "hello_world", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 4, + ), + name: CrateName( + "libc", + ), + prelude: true, + }, + ], + proc_macro: Err( + "crate has not (yet) been built", + ), + origin: CratesIo { + repo: None, + }, + is_proc_macro: false, + }, + CrateId( + 3, + ): CrateData { + root_file_id: FileId( + 4, + ), + edition: Edition2018, + version: Some( + "0.1.0", + ), + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "it", + ), + canonical_name: "it", + }, + ), + cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + potential_cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + env: Env { + entries: { + "CARGO_PKG_LICENSE": "", + "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_PKG_LICENSE_FILE": "", + "CARGO_PKG_HOMEPAGE": "", + "CARGO_PKG_DESCRIPTION": "", + "CARGO_PKG_NAME": "hello-world", + "CARGO_PKG_VERSION_PATCH": "0", + "CARGO": "cargo", + "CARGO_PKG_REPOSITORY": "", + "CARGO_PKG_VERSION_MINOR": "1", + "CARGO_PKG_VERSION_PRE": "", + }, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 0, + ), + name: CrateName( + "hello_world", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 4, + ), + name: CrateName( + "libc", + ), + prelude: true, + }, + ], + proc_macro: Err( + "crate has not (yet) been built", + ), + origin: CratesIo { + repo: None, + }, + is_proc_macro: false, + }, + }, + }"#]], + ) +} + +#[test] +fn cargo_hello_world_project_model() { + let crate_graph = load_cargo("hello-world-metadata.json"); + check_crate_graph( + crate_graph, + expect![[r#" + CrateGraph { + arena: { + CrateId( + 0, + ): CrateData { + root_file_id: FileId( + 1, + ), + edition: Edition2018, + version: Some( + "0.1.0", + ), + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "hello_world", + ), + canonical_name: "hello-world", + }, + ), + cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + potential_cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + env: Env { + entries: { + "CARGO_PKG_LICENSE": "", + "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_PKG_LICENSE_FILE": "", + "CARGO_PKG_HOMEPAGE": "", + "CARGO_PKG_DESCRIPTION": "", + "CARGO_PKG_NAME": "hello-world", + "CARGO_PKG_VERSION_PATCH": "0", + "CARGO": "cargo", + "CARGO_PKG_REPOSITORY": "", + "CARGO_PKG_VERSION_MINOR": "1", + "CARGO_PKG_VERSION_PRE": "", + }, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 4, + ), + name: CrateName( + "libc", + ), + prelude: true, + }, + ], + proc_macro: Err( + "crate has not (yet) been built", + ), + origin: CratesIo { + repo: None, + }, + is_proc_macro: false, + }, + CrateId( + 2, + ): CrateData { + root_file_id: FileId( + 3, + ), + edition: Edition2018, + version: Some( + "0.1.0", + ), + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "an_example", + ), + canonical_name: "an-example", + }, + ), + cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + potential_cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + env: Env { + entries: { + "CARGO_PKG_LICENSE": "", + "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_PKG_LICENSE_FILE": "", + "CARGO_PKG_HOMEPAGE": "", + "CARGO_PKG_DESCRIPTION": "", + "CARGO_PKG_NAME": "hello-world", + "CARGO_PKG_VERSION_PATCH": "0", + "CARGO": "cargo", + "CARGO_PKG_REPOSITORY": "", + "CARGO_PKG_VERSION_MINOR": "1", + "CARGO_PKG_VERSION_PRE": "", + }, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 0, + ), + name: CrateName( + "hello_world", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 4, + ), + name: CrateName( + "libc", + ), + prelude: true, + }, + ], + proc_macro: Err( + "crate has not (yet) been built", + ), + origin: CratesIo { + repo: None, + }, + is_proc_macro: false, + }, + CrateId( + 4, + ): CrateData { + root_file_id: FileId( + 5, + ), + edition: Edition2015, + version: Some( + "0.2.98", + ), + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "libc", + ), + canonical_name: "libc", + }, + ), + cfg_options: CfgOptions( + [ + "debug_assertions", + "feature=default", + "feature=std", + ], + ), + potential_cfg_options: CfgOptions( + [ + "debug_assertions", + "feature=align", + "feature=const-extern-fn", + "feature=default", + "feature=extra_traits", + "feature=rustc-dep-of-std", + "feature=std", + "feature=use_std", + ], + ), + env: Env { + entries: { + "CARGO_PKG_LICENSE": "", + "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_PKG_LICENSE_FILE": "", + "CARGO_PKG_HOMEPAGE": "", + "CARGO_PKG_DESCRIPTION": "", + "CARGO_PKG_NAME": "libc", + "CARGO_PKG_VERSION_PATCH": "98", + "CARGO": "cargo", + "CARGO_PKG_REPOSITORY": "", + "CARGO_PKG_VERSION_MINOR": "2", + "CARGO_PKG_VERSION_PRE": "", + }, + }, + dependencies: [], + proc_macro: Err( + "crate has not (yet) been built", + ), + origin: CratesIo { + repo: Some( + "https://github.com/rust-lang/libc", + ), + }, + is_proc_macro: false, + }, + CrateId( + 1, + ): CrateData { + root_file_id: FileId( + 2, + ), + edition: Edition2018, + version: Some( + "0.1.0", + ), + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "hello_world", + ), + canonical_name: "hello-world", + }, + ), + cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + potential_cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + env: Env { + entries: { + "CARGO_PKG_LICENSE": "", + "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_PKG_LICENSE_FILE": "", + "CARGO_PKG_HOMEPAGE": "", + "CARGO_PKG_DESCRIPTION": "", + "CARGO_PKG_NAME": "hello-world", + "CARGO_PKG_VERSION_PATCH": "0", + "CARGO": "cargo", + "CARGO_PKG_REPOSITORY": "", + "CARGO_PKG_VERSION_MINOR": "1", + "CARGO_PKG_VERSION_PRE": "", + }, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 0, + ), + name: CrateName( + "hello_world", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 4, + ), + name: CrateName( + "libc", + ), + prelude: true, + }, + ], + proc_macro: Err( + "crate has not (yet) been built", + ), + origin: CratesIo { + repo: None, + }, + is_proc_macro: false, + }, + CrateId( + 3, + ): CrateData { + root_file_id: FileId( + 4, + ), + edition: Edition2018, + version: Some( + "0.1.0", + ), + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "it", + ), + canonical_name: "it", + }, + ), + cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + potential_cfg_options: CfgOptions( + [ + "debug_assertions", + "test", + ], + ), + env: Env { + entries: { + "CARGO_PKG_LICENSE": "", + "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_PKG_LICENSE_FILE": "", + "CARGO_PKG_HOMEPAGE": "", + "CARGO_PKG_DESCRIPTION": "", + "CARGO_PKG_NAME": "hello-world", + "CARGO_PKG_VERSION_PATCH": "0", + "CARGO": "cargo", + "CARGO_PKG_REPOSITORY": "", + "CARGO_PKG_VERSION_MINOR": "1", + "CARGO_PKG_VERSION_PRE": "", + }, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 0, + ), + name: CrateName( + "hello_world", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 4, + ), + name: CrateName( + "libc", + ), + prelude: true, + }, + ], + proc_macro: Err( + "crate has not (yet) been built", + ), + origin: CratesIo { + repo: None, + }, + is_proc_macro: false, + }, + }, + }"#]], + ) +} + +#[test] +fn rust_project_hello_world_project_model() { + let crate_graph = load_rust_project("hello-world-project.json"); + check_crate_graph( + crate_graph, + expect![[r#" + CrateGraph { + arena: { + CrateId( + 0, + ): CrateData { + root_file_id: FileId( + 1, + ), + edition: Edition2018, + version: None, + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "alloc", + ), + canonical_name: "alloc", + }, + ), + cfg_options: CfgOptions( + [], + ), + potential_cfg_options: CfgOptions( + [], + ), + env: Env { + entries: {}, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 1, + ), + name: CrateName( + "core", + ), + prelude: true, + }, + ], + proc_macro: Err( + "no proc macro loaded for sysroot crate", + ), + origin: Lang( + Alloc, + ), + is_proc_macro: false, + }, + CrateId( + 10, + ): CrateData { + root_file_id: FileId( + 11, + ), + edition: Edition2018, + version: None, + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "unwind", + ), + canonical_name: "unwind", + }, + ), + cfg_options: CfgOptions( + [], + ), + potential_cfg_options: CfgOptions( + [], + ), + env: Env { + entries: {}, + }, + dependencies: [], + proc_macro: Err( + "no proc macro loaded for sysroot crate", + ), + origin: Lang( + Other, + ), + is_proc_macro: false, + }, + CrateId( + 7, + ): CrateData { + root_file_id: FileId( + 8, + ), + edition: Edition2018, + version: None, + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "std_detect", + ), + canonical_name: "std_detect", + }, + ), + cfg_options: CfgOptions( + [], + ), + potential_cfg_options: CfgOptions( + [], + ), + env: Env { + entries: {}, + }, + dependencies: [], + proc_macro: Err( + "no proc macro loaded for sysroot crate", + ), + origin: Lang( + Other, + ), + is_proc_macro: false, + }, + CrateId( + 4, + ): CrateData { + root_file_id: FileId( + 5, + ), + edition: Edition2018, + version: None, + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "proc_macro", + ), + canonical_name: "proc_macro", + }, + ), + cfg_options: CfgOptions( + [], + ), + potential_cfg_options: CfgOptions( + [], + ), + env: Env { + entries: {}, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 6, + ), + name: CrateName( + "std", + ), + prelude: true, + }, + ], + proc_macro: Err( + "no proc macro loaded for sysroot crate", + ), + origin: Lang( + Other, + ), + is_proc_macro: false, + }, + CrateId( + 1, + ): CrateData { + root_file_id: FileId( + 2, + ), + edition: Edition2018, + version: None, + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "core", + ), + canonical_name: "core", + }, + ), + cfg_options: CfgOptions( + [], + ), + potential_cfg_options: CfgOptions( + [], + ), + env: Env { + entries: {}, + }, + dependencies: [], + proc_macro: Err( + "no proc macro loaded for sysroot crate", + ), + origin: Lang( + Core, + ), + is_proc_macro: false, + }, + CrateId( + 11, + ): CrateData { + root_file_id: FileId( + 12, + ), + edition: Edition2018, + version: None, + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "hello_world", + ), + canonical_name: "hello_world", + }, + ), + cfg_options: CfgOptions( + [], + ), + potential_cfg_options: CfgOptions( + [], + ), + env: Env { + entries: {}, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 1, + ), + name: CrateName( + "core", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 0, + ), + name: CrateName( + "alloc", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 6, + ), + name: CrateName( + "std", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 9, + ), + name: CrateName( + "test", + ), + prelude: false, + }, + ], + proc_macro: Err( + "no proc macro dylib present", + ), + origin: CratesIo { + repo: None, + }, + is_proc_macro: false, + }, + CrateId( + 8, + ): CrateData { + root_file_id: FileId( + 9, + ), + edition: Edition2018, + version: None, + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "term", + ), + canonical_name: "term", + }, + ), + cfg_options: CfgOptions( + [], + ), + potential_cfg_options: CfgOptions( + [], + ), + env: Env { + entries: {}, + }, + dependencies: [], + proc_macro: Err( + "no proc macro loaded for sysroot crate", + ), + origin: Lang( + Other, + ), + is_proc_macro: false, + }, + CrateId( + 5, + ): CrateData { + root_file_id: FileId( + 6, + ), + edition: Edition2018, + version: None, + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "profiler_builtins", + ), + canonical_name: "profiler_builtins", + }, + ), + cfg_options: CfgOptions( + [], + ), + potential_cfg_options: CfgOptions( + [], + ), + env: Env { + entries: {}, + }, + dependencies: [], + proc_macro: Err( + "no proc macro loaded for sysroot crate", + ), + origin: Lang( + Other, + ), + is_proc_macro: false, + }, + CrateId( + 2, + ): CrateData { + root_file_id: FileId( + 3, + ), + edition: Edition2018, + version: None, + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "panic_abort", + ), + canonical_name: "panic_abort", + }, + ), + cfg_options: CfgOptions( + [], + ), + potential_cfg_options: CfgOptions( + [], + ), + env: Env { + entries: {}, + }, + dependencies: [], + proc_macro: Err( + "no proc macro loaded for sysroot crate", + ), + origin: Lang( + Other, + ), + is_proc_macro: false, + }, + CrateId( + 9, + ): CrateData { + root_file_id: FileId( + 10, + ), + edition: Edition2018, + version: None, + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "test", + ), + canonical_name: "test", + }, + ), + cfg_options: CfgOptions( + [], + ), + potential_cfg_options: CfgOptions( + [], + ), + env: Env { + entries: {}, + }, + dependencies: [], + proc_macro: Err( + "no proc macro loaded for sysroot crate", + ), + origin: Lang( + Test, + ), + is_proc_macro: false, + }, + CrateId( + 6, + ): CrateData { + root_file_id: FileId( + 7, + ), + edition: Edition2018, + version: None, + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "std", + ), + canonical_name: "std", + }, + ), + cfg_options: CfgOptions( + [], + ), + potential_cfg_options: CfgOptions( + [], + ), + env: Env { + entries: {}, + }, + dependencies: [ + Dependency { + crate_id: CrateId( + 0, + ), + name: CrateName( + "alloc", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 1, + ), + name: CrateName( + "core", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 2, + ), + name: CrateName( + "panic_abort", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 3, + ), + name: CrateName( + "panic_unwind", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 5, + ), + name: CrateName( + "profiler_builtins", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 7, + ), + name: CrateName( + "std_detect", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 8, + ), + name: CrateName( + "term", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 9, + ), + name: CrateName( + "test", + ), + prelude: true, + }, + Dependency { + crate_id: CrateId( + 10, + ), + name: CrateName( + "unwind", + ), + prelude: true, + }, + ], + proc_macro: Err( + "no proc macro loaded for sysroot crate", + ), + origin: Lang( + Std, + ), + is_proc_macro: false, + }, + CrateId( + 3, + ): CrateData { + root_file_id: FileId( + 4, + ), + edition: Edition2018, + version: None, + display_name: Some( + CrateDisplayName { + crate_name: CrateName( + "panic_unwind", + ), + canonical_name: "panic_unwind", + }, + ), + cfg_options: CfgOptions( + [], + ), + potential_cfg_options: CfgOptions( + [], + ), + env: Env { + entries: {}, + }, + dependencies: [], + proc_macro: Err( + "no proc macro loaded for sysroot crate", + ), + origin: Lang( + Other, + ), + is_proc_macro: false, + }, + }, + }"#]], + ); +} + +#[test] +fn rust_project_is_proc_macro_has_proc_macro_dep() { + let crate_graph = load_rust_project("is-proc-macro-project.json"); + // Since the project only defines one crate (outside the sysroot crates), + // it should be the one with the biggest Id. + let crate_id = crate_graph.iter().max().unwrap(); + let crate_data = &crate_graph[crate_id]; + // Assert that the project crate with `is_proc_macro` has a dependency + // on the proc_macro sysroot crate. + crate_data.dependencies.iter().find(|&dep| dep.name.deref() == "proc_macro").unwrap(); +} diff --git a/src/tools/rust-analyzer/crates/project-model/src/workspace.rs b/src/tools/rust-analyzer/crates/project-model/src/workspace.rs new file mode 100644 index 000000000..b144006b4 --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/src/workspace.rs @@ -0,0 +1,1032 @@ +//! Handles lowering of build-system specific workspace information (`cargo +//! metadata` or `rust-project.json`) into representation stored in the salsa +//! database -- `CrateGraph`. + +use std::{collections::VecDeque, fmt, fs, process::Command}; + +use anyhow::{format_err, Context, Result}; +use base_db::{ + CrateDisplayName, CrateGraph, CrateId, CrateName, CrateOrigin, Dependency, Edition, Env, + FileId, LangCrateOrigin, ProcMacroLoadResult, +}; +use cfg::{CfgDiff, CfgOptions}; +use paths::{AbsPath, AbsPathBuf}; +use rustc_hash::{FxHashMap, FxHashSet}; +use stdx::always; + +use crate::{ + build_scripts::BuildScriptOutput, + cargo_workspace::{DepKind, PackageData, RustcSource}, + cfg_flag::CfgFlag, + rustc_cfg, + sysroot::SysrootCrate, + utf8_stdout, CargoConfig, CargoWorkspace, ManifestPath, ProjectJson, ProjectManifest, Sysroot, + TargetKind, WorkspaceBuildScripts, +}; + +/// A set of cfg-overrides per crate. +/// +/// `Wildcard(..)` is useful e.g. disabling `#[cfg(test)]` on all crates, +/// without having to first obtain a list of all crates. +#[derive(Debug, Clone, Eq, PartialEq)] +pub enum CfgOverrides { + /// A single global set of overrides matching all crates. + Wildcard(CfgDiff), + /// A set of overrides matching specific crates. + Selective(FxHashMap<String, CfgDiff>), +} + +impl Default for CfgOverrides { + fn default() -> Self { + Self::Selective(FxHashMap::default()) + } +} + +impl CfgOverrides { + pub fn len(&self) -> usize { + match self { + CfgOverrides::Wildcard(_) => 1, + CfgOverrides::Selective(hash_map) => hash_map.len(), + } + } +} + +/// `PackageRoot` describes a package root folder. +/// Which may be an external dependency, or a member of +/// the current workspace. +#[derive(Debug, Clone, Eq, PartialEq, Hash)] +pub struct PackageRoot { + /// Is from the local filesystem and may be edited + pub is_local: bool, + pub include: Vec<AbsPathBuf>, + pub exclude: Vec<AbsPathBuf>, +} + +#[derive(Clone, Eq, PartialEq)] +pub enum ProjectWorkspace { + /// Project workspace was discovered by running `cargo metadata` and `rustc --print sysroot`. + Cargo { + cargo: CargoWorkspace, + build_scripts: WorkspaceBuildScripts, + sysroot: Option<Sysroot>, + rustc: Option<CargoWorkspace>, + /// Holds cfg flags for the current target. We get those by running + /// `rustc --print cfg`. + /// + /// FIXME: make this a per-crate map, as, eg, build.rs might have a + /// different target. + rustc_cfg: Vec<CfgFlag>, + cfg_overrides: CfgOverrides, + }, + /// Project workspace was manually specified using a `rust-project.json` file. + Json { project: ProjectJson, sysroot: Option<Sysroot>, rustc_cfg: Vec<CfgFlag> }, + + // 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. + // Ideally, you should be able to just open a random detached file in existing cargo projects, and get the basic features working. + // That needs some changes on the salsa-level though. + // 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). + // 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. + // 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. + // // + /// Project with a set of disjoint files, not belonging to any particular workspace. + /// Backed by basic sysroot crates for basic completion and highlighting. + DetachedFiles { files: Vec<AbsPathBuf>, sysroot: Sysroot, rustc_cfg: Vec<CfgFlag> }, +} + +impl fmt::Debug for ProjectWorkspace { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + // Make sure this isn't too verbose. + match self { + ProjectWorkspace::Cargo { + cargo, + build_scripts: _, + sysroot, + rustc, + rustc_cfg, + cfg_overrides, + } => f + .debug_struct("Cargo") + .field("root", &cargo.workspace_root().file_name()) + .field("n_packages", &cargo.packages().len()) + .field("sysroot", &sysroot.is_some()) + .field( + "n_rustc_compiler_crates", + &rustc.as_ref().map_or(0, |rc| rc.packages().len()), + ) + .field("n_rustc_cfg", &rustc_cfg.len()) + .field("n_cfg_overrides", &cfg_overrides.len()) + .finish(), + ProjectWorkspace::Json { project, sysroot, rustc_cfg } => { + let mut debug_struct = f.debug_struct("Json"); + debug_struct.field("n_crates", &project.n_crates()); + if let Some(sysroot) = sysroot { + debug_struct.field("n_sysroot_crates", &sysroot.crates().len()); + } + debug_struct.field("n_rustc_cfg", &rustc_cfg.len()); + debug_struct.finish() + } + ProjectWorkspace::DetachedFiles { files, sysroot, rustc_cfg } => f + .debug_struct("DetachedFiles") + .field("n_files", &files.len()) + .field("n_sysroot_crates", &sysroot.crates().len()) + .field("n_rustc_cfg", &rustc_cfg.len()) + .finish(), + } + } +} + +impl ProjectWorkspace { + pub fn load( + manifest: ProjectManifest, + config: &CargoConfig, + progress: &dyn Fn(String), + ) -> Result<ProjectWorkspace> { + let res = match manifest { + ProjectManifest::ProjectJson(project_json) => { + let file = fs::read_to_string(&project_json).with_context(|| { + format!("Failed to read json file {}", project_json.display()) + })?; + let data = serde_json::from_str(&file).with_context(|| { + format!("Failed to deserialize json file {}", project_json.display()) + })?; + let project_location = project_json.parent().to_path_buf(); + let project_json = ProjectJson::new(&project_location, data); + ProjectWorkspace::load_inline(project_json, config.target.as_deref())? + } + ProjectManifest::CargoToml(cargo_toml) => { + let cargo_version = utf8_stdout({ + let mut cmd = Command::new(toolchain::cargo()); + cmd.arg("--version"); + cmd + })?; + + let meta = CargoWorkspace::fetch_metadata( + &cargo_toml, + cargo_toml.parent(), + config, + progress, + ) + .with_context(|| { + format!( + "Failed to read Cargo metadata from Cargo.toml file {}, {}", + cargo_toml.display(), + cargo_version + ) + })?; + let cargo = CargoWorkspace::new(meta); + + let sysroot = if config.no_sysroot { + None + } else { + Some(Sysroot::discover(cargo_toml.parent()).with_context(|| { + format!( + "Failed to find sysroot for Cargo.toml file {}. Is rust-src installed?", + cargo_toml.display() + ) + })?) + }; + + let rustc_dir = match &config.rustc_source { + Some(RustcSource::Path(path)) => ManifestPath::try_from(path.clone()).ok(), + Some(RustcSource::Discover) => Sysroot::discover_rustc(&cargo_toml), + None => None, + }; + + let rustc = match rustc_dir { + Some(rustc_dir) => Some({ + let meta = CargoWorkspace::fetch_metadata( + &rustc_dir, + cargo_toml.parent(), + config, + progress, + ) + .with_context(|| { + "Failed to read Cargo metadata for Rust sources".to_string() + })?; + CargoWorkspace::new(meta) + }), + None => None, + }; + + let rustc_cfg = rustc_cfg::get(Some(&cargo_toml), config.target.as_deref()); + + let cfg_overrides = config.cfg_overrides(); + ProjectWorkspace::Cargo { + cargo, + build_scripts: WorkspaceBuildScripts::default(), + sysroot, + rustc, + rustc_cfg, + cfg_overrides, + } + } + }; + + Ok(res) + } + + pub fn load_inline( + project_json: ProjectJson, + target: Option<&str>, + ) -> Result<ProjectWorkspace> { + let sysroot = match (project_json.sysroot.clone(), project_json.sysroot_src.clone()) { + (Some(sysroot), Some(sysroot_src)) => Some(Sysroot::load(sysroot, sysroot_src)?), + (Some(sysroot), None) => { + // assume sysroot is structured like rustup's and guess `sysroot_src` + let sysroot_src = + sysroot.join("lib").join("rustlib").join("src").join("rust").join("library"); + + Some(Sysroot::load(sysroot, sysroot_src)?) + } + (None, Some(sysroot_src)) => { + // assume sysroot is structured like rustup's and guess `sysroot` + let mut sysroot = sysroot_src.clone(); + for _ in 0..5 { + sysroot.pop(); + } + Some(Sysroot::load(sysroot, sysroot_src)?) + } + (None, None) => None, + }; + + let rustc_cfg = rustc_cfg::get(None, target); + Ok(ProjectWorkspace::Json { project: project_json, sysroot, rustc_cfg }) + } + + pub fn load_detached_files(detached_files: Vec<AbsPathBuf>) -> Result<ProjectWorkspace> { + let sysroot = Sysroot::discover( + detached_files + .first() + .and_then(|it| it.parent()) + .ok_or_else(|| format_err!("No detached files to load"))?, + )?; + let rustc_cfg = rustc_cfg::get(None, None); + Ok(ProjectWorkspace::DetachedFiles { files: detached_files, sysroot, rustc_cfg }) + } + + pub fn run_build_scripts( + &self, + config: &CargoConfig, + progress: &dyn Fn(String), + ) -> Result<WorkspaceBuildScripts> { + match self { + ProjectWorkspace::Cargo { cargo, .. } => { + WorkspaceBuildScripts::run(config, cargo, progress).with_context(|| { + format!("Failed to run build scripts for {}", &cargo.workspace_root().display()) + }) + } + ProjectWorkspace::Json { .. } | ProjectWorkspace::DetachedFiles { .. } => { + Ok(WorkspaceBuildScripts::default()) + } + } + } + + pub fn set_build_scripts(&mut self, bs: WorkspaceBuildScripts) { + match self { + ProjectWorkspace::Cargo { build_scripts, .. } => *build_scripts = bs, + _ => { + always!(bs == WorkspaceBuildScripts::default()); + } + } + } + + /// Returns the roots for the current `ProjectWorkspace` + /// The return type contains the path and whether or not + /// the root is a member of the current workspace + pub fn to_roots(&self) -> Vec<PackageRoot> { + match self { + ProjectWorkspace::Json { project, sysroot, rustc_cfg: _ } => project + .crates() + .map(|(_, krate)| PackageRoot { + is_local: krate.is_workspace_member, + include: krate.include.clone(), + exclude: krate.exclude.clone(), + }) + .collect::<FxHashSet<_>>() + .into_iter() + .chain(sysroot.as_ref().into_iter().flat_map(|sysroot| { + sysroot.crates().map(move |krate| PackageRoot { + is_local: false, + include: vec![sysroot[krate].root.parent().to_path_buf()], + exclude: Vec::new(), + }) + })) + .collect::<Vec<_>>(), + ProjectWorkspace::Cargo { + cargo, + sysroot, + rustc, + rustc_cfg: _, + cfg_overrides: _, + build_scripts, + } => { + cargo + .packages() + .map(|pkg| { + let is_local = cargo[pkg].is_local; + let pkg_root = cargo[pkg].manifest.parent().to_path_buf(); + + let mut include = vec![pkg_root.clone()]; + let out_dir = + build_scripts.get_output(pkg).and_then(|it| it.out_dir.clone()); + include.extend(out_dir); + + // In case target's path is manually set in Cargo.toml to be + // outside the package root, add its parent as an extra include. + // An example of this situation would look like this: + // + // ```toml + // [lib] + // path = "../../src/lib.rs" + // ``` + let extra_targets = cargo[pkg] + .targets + .iter() + .filter(|&&tgt| cargo[tgt].kind == TargetKind::Lib) + .filter_map(|&tgt| cargo[tgt].root.parent()) + .map(|tgt| tgt.normalize().to_path_buf()) + .filter(|path| !path.starts_with(&pkg_root)); + include.extend(extra_targets); + + let mut exclude = vec![pkg_root.join(".git")]; + if is_local { + exclude.push(pkg_root.join("target")); + } else { + exclude.push(pkg_root.join("tests")); + exclude.push(pkg_root.join("examples")); + exclude.push(pkg_root.join("benches")); + } + PackageRoot { is_local, include, exclude } + }) + .chain(sysroot.iter().map(|sysroot| PackageRoot { + is_local: false, + include: vec![sysroot.src_root().to_path_buf()], + exclude: Vec::new(), + })) + .chain(rustc.iter().flat_map(|rustc| { + rustc.packages().map(move |krate| PackageRoot { + is_local: false, + include: vec![rustc[krate].manifest.parent().to_path_buf()], + exclude: Vec::new(), + }) + })) + .collect() + } + ProjectWorkspace::DetachedFiles { files, sysroot, .. } => files + .iter() + .map(|detached_file| PackageRoot { + is_local: true, + include: vec![detached_file.clone()], + exclude: Vec::new(), + }) + .chain(sysroot.crates().map(|krate| PackageRoot { + is_local: false, + include: vec![sysroot[krate].root.parent().to_path_buf()], + exclude: Vec::new(), + })) + .collect(), + } + } + + pub fn n_packages(&self) -> usize { + match self { + ProjectWorkspace::Json { project, .. } => project.n_crates(), + ProjectWorkspace::Cargo { cargo, sysroot, rustc, .. } => { + let rustc_package_len = rustc.as_ref().map_or(0, |it| it.packages().len()); + let sysroot_package_len = sysroot.as_ref().map_or(0, |it| it.crates().len()); + cargo.packages().len() + sysroot_package_len + rustc_package_len + } + ProjectWorkspace::DetachedFiles { sysroot, files, .. } => { + sysroot.crates().len() + files.len() + } + } + } + + pub fn to_crate_graph( + &self, + load_proc_macro: &mut dyn FnMut(&str, &AbsPath) -> ProcMacroLoadResult, + load: &mut dyn FnMut(&AbsPath) -> Option<FileId>, + ) -> CrateGraph { + let _p = profile::span("ProjectWorkspace::to_crate_graph"); + + let mut crate_graph = match self { + ProjectWorkspace::Json { project, sysroot, rustc_cfg } => project_json_to_crate_graph( + rustc_cfg.clone(), + load_proc_macro, + load, + project, + sysroot, + ), + ProjectWorkspace::Cargo { + cargo, + sysroot, + rustc, + rustc_cfg, + cfg_overrides, + build_scripts, + } => cargo_to_crate_graph( + rustc_cfg.clone(), + cfg_overrides, + load_proc_macro, + load, + cargo, + build_scripts, + sysroot.as_ref(), + rustc, + ), + ProjectWorkspace::DetachedFiles { files, sysroot, rustc_cfg } => { + detached_files_to_crate_graph(rustc_cfg.clone(), load, files, sysroot) + } + }; + if crate_graph.patch_cfg_if() { + tracing::debug!("Patched std to depend on cfg-if") + } else { + tracing::debug!("Did not patch std to depend on cfg-if") + } + crate_graph + } +} + +fn project_json_to_crate_graph( + rustc_cfg: Vec<CfgFlag>, + load_proc_macro: &mut dyn FnMut(&str, &AbsPath) -> ProcMacroLoadResult, + load: &mut dyn FnMut(&AbsPath) -> Option<FileId>, + project: &ProjectJson, + sysroot: &Option<Sysroot>, +) -> CrateGraph { + let mut crate_graph = CrateGraph::default(); + let sysroot_deps = sysroot + .as_ref() + .map(|sysroot| sysroot_to_crate_graph(&mut crate_graph, sysroot, rustc_cfg.clone(), load)); + + let mut cfg_cache: FxHashMap<&str, Vec<CfgFlag>> = FxHashMap::default(); + let crates: FxHashMap<CrateId, CrateId> = project + .crates() + .filter_map(|(crate_id, krate)| { + let file_path = &krate.root_module; + let file_id = load(file_path)?; + Some((crate_id, krate, file_id)) + }) + .map(|(crate_id, krate, file_id)| { + let env = krate.env.clone().into_iter().collect(); + let proc_macro = match krate.proc_macro_dylib_path.clone() { + Some(it) => load_proc_macro( + krate.display_name.as_ref().map(|it| it.canonical_name()).unwrap_or(""), + &it, + ), + None => Err("no proc macro dylib present".into()), + }; + + let target_cfgs = match krate.target.as_deref() { + Some(target) => { + cfg_cache.entry(target).or_insert_with(|| rustc_cfg::get(None, Some(target))) + } + None => &rustc_cfg, + }; + + let mut cfg_options = CfgOptions::default(); + cfg_options.extend(target_cfgs.iter().chain(krate.cfg.iter()).cloned()); + ( + crate_id, + crate_graph.add_crate_root( + file_id, + krate.edition, + krate.display_name.clone(), + krate.version.clone(), + cfg_options.clone(), + cfg_options, + env, + proc_macro, + krate.is_proc_macro, + if krate.display_name.is_some() { + CrateOrigin::CratesIo { repo: krate.repository.clone() } + } else { + CrateOrigin::CratesIo { repo: None } + }, + ), + ) + }) + .collect(); + + for (from, krate) in project.crates() { + if let Some(&from) = crates.get(&from) { + if let Some((public_deps, libproc_macro)) = &sysroot_deps { + public_deps.add(from, &mut crate_graph); + if krate.is_proc_macro { + if let Some(proc_macro) = libproc_macro { + add_dep( + &mut crate_graph, + from, + CrateName::new("proc_macro").unwrap(), + *proc_macro, + ); + } + } + } + + for dep in &krate.deps { + if let Some(&to) = crates.get(&dep.crate_id) { + add_dep(&mut crate_graph, from, dep.name.clone(), to) + } + } + } + } + crate_graph +} + +fn cargo_to_crate_graph( + rustc_cfg: Vec<CfgFlag>, + override_cfg: &CfgOverrides, + load_proc_macro: &mut dyn FnMut(&str, &AbsPath) -> ProcMacroLoadResult, + load: &mut dyn FnMut(&AbsPath) -> Option<FileId>, + cargo: &CargoWorkspace, + build_scripts: &WorkspaceBuildScripts, + sysroot: Option<&Sysroot>, + rustc: &Option<CargoWorkspace>, +) -> CrateGraph { + let _p = profile::span("cargo_to_crate_graph"); + let mut crate_graph = CrateGraph::default(); + let (public_deps, libproc_macro) = match sysroot { + Some(sysroot) => sysroot_to_crate_graph(&mut crate_graph, sysroot, rustc_cfg.clone(), load), + None => (SysrootPublicDeps::default(), None), + }; + + let mut cfg_options = CfgOptions::default(); + cfg_options.extend(rustc_cfg); + + let mut pkg_to_lib_crate = FxHashMap::default(); + + cfg_options.insert_atom("debug_assertions".into()); + + 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; + // Next, create crates for each package, target pair + for pkg in cargo.packages() { + let mut cfg_options = cfg_options.clone(); + + let overrides = match override_cfg { + CfgOverrides::Wildcard(cfg_diff) => Some(cfg_diff), + CfgOverrides::Selective(cfg_overrides) => cfg_overrides.get(&cargo[pkg].name), + }; + + // Add test cfg for local crates + if cargo[pkg].is_local { + cfg_options.insert_atom("test".into()); + } + + if let Some(overrides) = overrides { + // 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(overrides.clone()); + }; + + has_private |= cargo[pkg].metadata.rustc_private; + let mut lib_tgt = None; + for &tgt in cargo[pkg].targets.iter() { + if cargo[tgt].kind != TargetKind::Lib && !cargo[pkg].is_member { + // 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. + // In fact, they can break quite badly if multiple client workspaces get merged: + // https://github.com/rust-lang/rust-analyzer/issues/11300 + continue; + } + + if let Some(file_id) = load(&cargo[tgt].root) { + let crate_id = add_target_crate_root( + &mut crate_graph, + &cargo[pkg], + build_scripts.get_output(pkg), + cfg_options.clone(), + &mut |path| load_proc_macro(&cargo[tgt].name, path), + file_id, + &cargo[tgt].name, + cargo[tgt].is_proc_macro, + ); + if cargo[tgt].kind == TargetKind::Lib { + lib_tgt = Some((crate_id, cargo[tgt].name.clone())); + pkg_to_lib_crate.insert(pkg, crate_id); + } + if let Some(proc_macro) = libproc_macro { + add_dep_with_prelude( + &mut crate_graph, + crate_id, + CrateName::new("proc_macro").unwrap(), + proc_macro, + cargo[tgt].is_proc_macro, + ); + } + + pkg_crates.entry(pkg).or_insert_with(Vec::new).push((crate_id, cargo[tgt].kind)); + } + } + + // Set deps to the core, std and to the lib target of the current package + for (from, kind) in pkg_crates.get(&pkg).into_iter().flatten() { + // Add sysroot deps first so that a lib target named `core` etc. can overwrite them. + public_deps.add(*from, &mut crate_graph); + + if let Some((to, name)) = lib_tgt.clone() { + if to != *from && *kind != TargetKind::BuildScript { + // (build script can not depend on its library target) + + // For root projects with dashes in their name, + // cargo metadata does not do any normalization, + // so we do it ourselves currently + let name = CrateName::normalize_dashes(&name); + add_dep(&mut crate_graph, *from, name, to); + } + } + } + } + + // Now add a dep edge from all targets of upstream to the lib + // target of downstream. + for pkg in cargo.packages() { + for dep in cargo[pkg].dependencies.iter() { + let name = CrateName::new(&dep.name).unwrap(); + if let Some(&to) = pkg_to_lib_crate.get(&dep.pkg) { + for (from, kind) in pkg_crates.get(&pkg).into_iter().flatten() { + if dep.kind == DepKind::Build && *kind != TargetKind::BuildScript { + // Only build scripts may depend on build dependencies. + continue; + } + if dep.kind != DepKind::Build && *kind == TargetKind::BuildScript { + // Build scripts may only depend on build dependencies. + continue; + } + + add_dep(&mut crate_graph, *from, name.clone(), to) + } + } + } + } + + if has_private { + // If the user provided a path to rustc sources, we add all the rustc_private crates + // and create dependencies on them for the crates which opt-in to that + if let Some(rustc_workspace) = rustc { + handle_rustc_crates( + rustc_workspace, + load, + &mut crate_graph, + &cfg_options, + override_cfg, + load_proc_macro, + &mut pkg_to_lib_crate, + &public_deps, + cargo, + &pkg_crates, + build_scripts, + ); + } + } + crate_graph +} + +fn detached_files_to_crate_graph( + rustc_cfg: Vec<CfgFlag>, + load: &mut dyn FnMut(&AbsPath) -> Option<FileId>, + detached_files: &[AbsPathBuf], + sysroot: &Sysroot, +) -> CrateGraph { + let _p = profile::span("detached_files_to_crate_graph"); + 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 cfg_options = CfgOptions::default(); + cfg_options.extend(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() + .and_then(|os_str| os_str.to_str()) + .map(|file_stem| CrateDisplayName::from_canonical_name(file_stem.to_string())); + let detached_file_crate = crate_graph.add_crate_root( + file_id, + Edition::CURRENT, + display_name, + None, + cfg_options.clone(), + cfg_options.clone(), + Env::default(), + Ok(Vec::new()), + false, + CrateOrigin::CratesIo { repo: None }, + ); + + public_deps.add(detached_file_crate, &mut crate_graph); + } + crate_graph +} + +fn handle_rustc_crates( + rustc_workspace: &CargoWorkspace, + load: &mut dyn FnMut(&AbsPath) -> Option<FileId>, + crate_graph: &mut CrateGraph, + cfg_options: &CfgOptions, + override_cfg: &CfgOverrides, + load_proc_macro: &mut dyn FnMut(&str, &AbsPath) -> ProcMacroLoadResult, + pkg_to_lib_crate: &mut FxHashMap<la_arena::Idx<crate::PackageData>, CrateId>, + public_deps: &SysrootPublicDeps, + cargo: &CargoWorkspace, + pkg_crates: &FxHashMap<la_arena::Idx<crate::PackageData>, Vec<(CrateId, TargetKind)>>, + build_scripts: &WorkspaceBuildScripts, +) { + 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"); + // 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 { + // Iterate through every crate in the dependency subtree of rustc_driver using BFS + let mut queue = VecDeque::new(); + queue.push_back(root_pkg); + while let Some(pkg) = queue.pop_front() { + // Don't duplicate packages if they are dependended on a diamond pattern + // N.B. if this line is ommitted, we try to analyse over 4_800_000 crates + // which is not ideal + if rustc_pkg_crates.contains_key(&pkg) { + continue; + } + for dep in &rustc_workspace[pkg].dependencies { + queue.push_back(dep.pkg); + } + + let mut cfg_options = cfg_options.clone(); + + let overrides = match override_cfg { + CfgOverrides::Wildcard(cfg_diff) => Some(cfg_diff), + CfgOverrides::Selective(cfg_overrides) => { + cfg_overrides.get(&rustc_workspace[pkg].name) + } + }; + + if let Some(overrides) = overrides { + // 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(overrides.clone()); + }; + + for &tgt in rustc_workspace[pkg].targets.iter() { + if rustc_workspace[tgt].kind != TargetKind::Lib { + continue; + } + if let Some(file_id) = load(&rustc_workspace[tgt].root) { + let crate_id = add_target_crate_root( + crate_graph, + &rustc_workspace[pkg], + build_scripts.get_output(pkg), + cfg_options.clone(), + &mut |path| load_proc_macro(&rustc_workspace[tgt].name, path), + file_id, + &rustc_workspace[tgt].name, + rustc_workspace[tgt].is_proc_macro, + ); + pkg_to_lib_crate.insert(pkg, crate_id); + // Add dependencies on core / std / alloc for this crate + public_deps.add(crate_id, crate_graph); + rustc_pkg_crates.entry(pkg).or_insert_with(Vec::new).push(crate_id); + } + } + } + } + // Now add a dep edge from all targets of upstream to the lib + // target of downstream. + for pkg in rustc_pkg_crates.keys().copied() { + for dep in rustc_workspace[pkg].dependencies.iter() { + let name = CrateName::new(&dep.name).unwrap(); + if let Some(&to) = pkg_to_lib_crate.get(&dep.pkg) { + for &from in rustc_pkg_crates.get(&pkg).into_iter().flatten() { + add_dep(crate_graph, from, name.clone(), to); + } + } + } + } + // Add a dependency on the rustc_private crates for all targets of each package + // which opts in + for dep in rustc_workspace.packages() { + let name = CrateName::normalize_dashes(&rustc_workspace[dep].name); + + if let Some(&to) = pkg_to_lib_crate.get(&dep) { + for pkg in cargo.packages() { + let package = &cargo[pkg]; + if !package.metadata.rustc_private { + continue; + } + for (from, _) in pkg_crates.get(&pkg).into_iter().flatten() { + // Avoid creating duplicate dependencies + // 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) { + add_dep(crate_graph, *from, name.clone(), to); + } + } + } + } + } +} + +fn add_target_crate_root( + crate_graph: &mut CrateGraph, + pkg: &PackageData, + build_data: Option<&BuildScriptOutput>, + cfg_options: CfgOptions, + load_proc_macro: &mut dyn FnMut(&AbsPath) -> ProcMacroLoadResult, + file_id: FileId, + cargo_name: &str, + is_proc_macro: bool, +) -> CrateId { + let edition = pkg.edition; + let mut potential_cfg_options = cfg_options.clone(); + potential_cfg_options.extend( + pkg.features + .iter() + .map(|feat| CfgFlag::KeyValue { key: "feature".into(), value: feat.0.into() }), + ); + let cfg_options = { + let mut opts = cfg_options; + for feature in pkg.active_features.iter() { + opts.insert_key_value("feature".into(), feature.into()); + } + if let Some(cfgs) = build_data.as_ref().map(|it| &it.cfgs) { + opts.extend(cfgs.iter().cloned()); + } + opts + }; + + let mut env = Env::default(); + inject_cargo_env(pkg, &mut env); + + if let Some(envs) = build_data.map(|it| &it.envs) { + for (k, v) in envs { + env.set(k, v.clone()); + } + } + + let proc_macro = match build_data.as_ref().map(|it| it.proc_macro_dylib_path.as_ref()) { + Some(Some(it)) => load_proc_macro(it), + Some(None) => Err("no proc macro dylib present".into()), + None => Err("crate has not (yet) been built".into()), + }; + + let display_name = CrateDisplayName::from_canonical_name(cargo_name.to_string()); + crate_graph.add_crate_root( + file_id, + edition, + Some(display_name), + Some(pkg.version.to_string()), + cfg_options, + potential_cfg_options, + env, + proc_macro, + is_proc_macro, + CrateOrigin::CratesIo { repo: pkg.repository.clone() }, + ) +} + +#[derive(Default)] +struct SysrootPublicDeps { + deps: Vec<(CrateName, CrateId, bool)>, +} + +impl SysrootPublicDeps { + /// Makes `from` depend on the public sysroot crates. + fn add(&self, from: CrateId, crate_graph: &mut CrateGraph) { + for (name, krate, prelude) in &self.deps { + add_dep_with_prelude(crate_graph, from, name.clone(), *krate, *prelude); + } + } +} + +fn sysroot_to_crate_graph( + crate_graph: &mut CrateGraph, + sysroot: &Sysroot, + rustc_cfg: Vec<CfgFlag>, + load: &mut dyn FnMut(&AbsPath) -> Option<FileId>, +) -> (SysrootPublicDeps, Option<CrateId>) { + let _p = profile::span("sysroot_to_crate_graph"); + let mut cfg_options = CfgOptions::default(); + cfg_options.extend(rustc_cfg); + let sysroot_crates: FxHashMap<SysrootCrate, CrateId> = sysroot + .crates() + .filter_map(|krate| { + let file_id = load(&sysroot[krate].root)?; + + let env = Env::default(); + let display_name = CrateDisplayName::from_canonical_name(sysroot[krate].name.clone()); + let crate_id = crate_graph.add_crate_root( + file_id, + Edition::CURRENT, + Some(display_name), + None, + cfg_options.clone(), + cfg_options.clone(), + env, + Err("no proc macro loaded for sysroot crate".into()), + false, + CrateOrigin::Lang(LangCrateOrigin::from(&*sysroot[krate].name)), + ); + Some((krate, crate_id)) + }) + .collect(); + + for from in sysroot.crates() { + for &to in sysroot[from].deps.iter() { + let name = CrateName::new(&sysroot[to].name).unwrap(); + if let (Some(&from), Some(&to)) = (sysroot_crates.get(&from), sysroot_crates.get(&to)) { + add_dep(crate_graph, from, name, to); + } + } + } + + let public_deps = SysrootPublicDeps { + deps: sysroot + .public_deps() + .map(|(name, idx, prelude)| { + (CrateName::new(name).unwrap(), sysroot_crates[&idx], prelude) + }) + .collect::<Vec<_>>(), + }; + + let libproc_macro = sysroot.proc_macro().and_then(|it| sysroot_crates.get(&it).copied()); + (public_deps, libproc_macro) +} + +fn add_dep(graph: &mut CrateGraph, from: CrateId, name: CrateName, to: CrateId) { + add_dep_inner(graph, from, Dependency::new(name, to)) +} + +fn add_dep_with_prelude( + graph: &mut CrateGraph, + from: CrateId, + name: CrateName, + to: CrateId, + prelude: bool, +) { + add_dep_inner(graph, from, Dependency::with_prelude(name, to, prelude)) +} + +fn add_dep_inner(graph: &mut CrateGraph, from: CrateId, dep: Dependency) { + if let Err(err) = graph.add_dep(from, dep) { + 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_os_str().to_string_lossy().into_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()); +} diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/alloc/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/alloc/src/lib.rs new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/alloc/src/lib.rs diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/core/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/core/src/lib.rs new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/core/src/lib.rs diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/panic_abort/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/panic_abort/src/lib.rs new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/panic_abort/src/lib.rs diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/panic_unwind/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/panic_unwind/src/lib.rs new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/panic_unwind/src/lib.rs diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/proc_macro/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/proc_macro/src/lib.rs new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/proc_macro/src/lib.rs diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/profiler_builtins/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/profiler_builtins/src/lib.rs new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/profiler_builtins/src/lib.rs diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/std/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/std/src/lib.rs new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/std/src/lib.rs diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/stdarch/crates/std_detect/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/stdarch/crates/std_detect/src/lib.rs new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/stdarch/crates/std_detect/src/lib.rs diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/term/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/term/src/lib.rs new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/term/src/lib.rs diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/test/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/test/src/lib.rs new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/test/src/lib.rs diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/unwind/src/lib.rs b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/unwind/src/lib.rs new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/test_data/fake-sysroot/unwind/src/lib.rs diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/hello-world-metadata.json b/src/tools/rust-analyzer/crates/project-model/test_data/hello-world-metadata.json new file mode 100644 index 000000000..b6142eeaf --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/test_data/hello-world-metadata.json @@ -0,0 +1,245 @@ +{ + "packages": [ + { + "name": "hello-world", + "version": "0.1.0", + "id": "hello-world 0.1.0 (path+file://$ROOT$hello-world)", + "license": null, + "license_file": null, + "description": null, + "source": null, + "dependencies": [ + { + "name": "libc", + "source": "registry+https://github.com/rust-lang/crates.io-index", + "req": "^0.2", + "kind": null, + "rename": null, + "optional": false, + "uses_default_features": true, + "features": [], + "target": null, + "registry": null + } + ], + "targets": [ + { + "kind": [ + "lib" + ], + "crate_types": [ + "lib" + ], + "name": "hello-world", + "src_path": "$ROOT$hello-world/src/lib.rs", + "edition": "2018", + "doc": true, + "doctest": true, + "test": true + }, + { + "kind": [ + "bin" + ], + "crate_types": [ + "bin" + ], + "name": "hello-world", + "src_path": "$ROOT$hello-world/src/main.rs", + "edition": "2018", + "doc": true, + "doctest": false, + "test": true + }, + { + "kind": [ + "example" + ], + "crate_types": [ + "bin" + ], + "name": "an-example", + "src_path": "$ROOT$hello-world/examples/an-example.rs", + "edition": "2018", + "doc": false, + "doctest": false, + "test": false + }, + { + "kind": [ + "test" + ], + "crate_types": [ + "bin" + ], + "name": "it", + "src_path": "$ROOT$hello-world/tests/it.rs", + "edition": "2018", + "doc": false, + "doctest": false, + "test": true + } + ], + "features": {}, + "manifest_path": "$ROOT$hello-world/Cargo.toml", + "metadata": null, + "publish": null, + "authors": [], + "categories": [], + "keywords": [], + "readme": null, + "repository": null, + "homepage": null, + "documentation": null, + "edition": "2018", + "links": null + }, + { + "name": "libc", + "version": "0.2.98", + "id": "libc 0.2.98 (registry+https://github.com/rust-lang/crates.io-index)", + "license": "MIT OR Apache-2.0", + "license_file": null, + "description": "Raw FFI bindings to platform libraries like libc.\n", + "source": "registry+https://github.com/rust-lang/crates.io-index", + "dependencies": [ + { + "name": "rustc-std-workspace-core", + "source": "registry+https://github.com/rust-lang/crates.io-index", + "req": "^1.0.0", + "kind": null, + "rename": null, + "optional": true, + "uses_default_features": true, + "features": [], + "target": null, + "registry": null + } + ], + "targets": [ + { + "kind": [ + "lib" + ], + "crate_types": [ + "lib" + ], + "name": "libc", + "src_path": "$ROOT$.cargo/registry/src/github.com-1ecc6299db9ec823/libc-0.2.98/src/lib.rs", + "edition": "2015", + "doc": true, + "doctest": true, + "test": true + }, + { + "kind": [ + "test" + ], + "crate_types": [ + "bin" + ], + "name": "const_fn", + "src_path": "$ROOT$.cargo/registry/src/github.com-1ecc6299db9ec823/libc-0.2.98/tests/const_fn.rs", + "edition": "2015", + "doc": false, + "doctest": false, + "test": true + }, + { + "kind": [ + "custom-build" + ], + "crate_types": [ + "bin" + ], + "name": "build-script-build", + "src_path": "$ROOT$.cargo/registry/src/github.com-1ecc6299db9ec823/libc-0.2.98/build.rs", + "edition": "2015", + "doc": false, + "doctest": false, + "test": false + } + ], + "features": { + "align": [], + "const-extern-fn": [], + "default": [ + "std" + ], + "extra_traits": [], + "rustc-dep-of-std": [ + "align", + "rustc-std-workspace-core" + ], + "std": [], + "use_std": [ + "std" + ] + }, + "manifest_path": "$ROOT$.cargo/registry/src/github.com-1ecc6299db9ec823/libc-0.2.98/Cargo.toml", + "metadata": null, + "publish": null, + "authors": [ + "The Rust Project Developers" + ], + "categories": [ + "external-ffi-bindings", + "no-std", + "os" + ], + "keywords": [ + "libc", + "ffi", + "bindings", + "operating", + "system" + ], + "readme": "README.md", + "repository": "https://github.com/rust-lang/libc", + "homepage": "https://github.com/rust-lang/libc", + "documentation": "https://docs.rs/libc/", + "edition": "2015", + "links": null + } + ], + "workspace_members": [ + "hello-world 0.1.0 (path+file://$ROOT$hello-world)" + ], + "resolve": { + "nodes": [ + { + "id": "hello-world 0.1.0 (path+file://$ROOT$hello-world)", + "dependencies": [ + "libc 0.2.98 (registry+https://github.com/rust-lang/crates.io-index)" + ], + "deps": [ + { + "name": "libc", + "pkg": "libc 0.2.98 (registry+https://github.com/rust-lang/crates.io-index)", + "dep_kinds": [ + { + "kind": null, + "target": null + } + ] + } + ], + "features": [] + }, + { + "id": "libc 0.2.98 (registry+https://github.com/rust-lang/crates.io-index)", + "dependencies": [], + "deps": [], + "features": [ + "default", + "std" + ] + } + ], + "root": "hello-world 0.1.0 (path+file://$ROOT$hello-world)" + }, + "target_directory": "$ROOT$hello-world/target", + "version": 1, + "workspace_root": "$ROOT$hello-world", + "metadata": null +} diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/hello-world-project.json b/src/tools/rust-analyzer/crates/project-model/test_data/hello-world-project.json new file mode 100644 index 000000000..b27ab1f42 --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/test_data/hello-world-project.json @@ -0,0 +1,12 @@ +{ + "sysroot_src": null, + "crates": [ + { + "display_name": "hello_world", + "root_module": "$ROOT$src/lib.rs", + "edition": "2018", + "deps": [], + "is_workspace_member": true + } + ] +} diff --git a/src/tools/rust-analyzer/crates/project-model/test_data/is-proc-macro-project.json b/src/tools/rust-analyzer/crates/project-model/test_data/is-proc-macro-project.json new file mode 100644 index 000000000..5d500a472 --- /dev/null +++ b/src/tools/rust-analyzer/crates/project-model/test_data/is-proc-macro-project.json @@ -0,0 +1,13 @@ +{ + "sysroot_src": null, + "crates": [ + { + "display_name": "is_proc_macro", + "root_module": "$ROOT$src/lib.rs", + "edition": "2018", + "deps": [], + "is_workspace_member": true, + "is_proc_macro": true + } + ] +} |